RAHHH

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Map.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: wamp
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Map(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Map()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMap(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Map
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Map
+    def Key(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Map
+    def Value(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def MapStart(builder): builder.StartObject(2)
+def Start(builder):
+    return MapStart(builder)
+def MapAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+def AddKey(builder, key):
+    return MapAddKey(builder, key)
+def MapAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+def AddValue(builder, value):
+    return MapAddValue(builder, value)
+def MapEnd(builder): return builder.EndObject()
+def End(builder):
+    return MapEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Void.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: wamp
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Void(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Void()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsVoid(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Void
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def VoidStart(builder): builder.StartObject(0)
+def Start(builder):
+    return VoidStart(builder)
+def VoidEnd(builder): return builder.EndObject()
+def End(builder):
+    return VoidEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Abort.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Abort(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Abort()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAbort(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Abort
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Abort
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Abort
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Abort
+    def Message(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def AbortStart(builder): builder.StartObject(3)
+def Start(builder):
+    return AbortStart(builder)
+def AbortAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return AbortAddSession(builder, session)
+def AbortAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return AbortAddReason(builder, reason)
+def AbortAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+def AddMessage(builder, message):
+    return AbortAddMessage(builder, message)
+def AbortEnd(builder): return builder.EndObject()
+def End(builder):
+    return AbortEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AnyMessage.py

@@ -0,0 +1,31 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AnyMessage(object):
+    NONE = 0
+    Hello = 1
+    Welcome = 2
+    Abort = 3
+    Challenge = 4
+    Authenticate = 5
+    Goodbye = 6
+    Error = 7
+    Publish = 8
+    Published = 9
+    Subscribe = 10
+    Subscribed = 11
+    Unsubscribe = 12
+    Unsubscribed = 13
+    Event = 14
+    EventReceived = 15
+    Call = 16
+    Cancel = 17
+    Result = 18
+    Register = 19
+    Registered = 20
+    Unregister = 21
+    Unregistered = 22
+    Invocation = 23
+    Interrupt = 24
+    Yield = 25

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraChallenge.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCraChallenge
+    def Challenge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCraChallenge
+    def Salt(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCraChallenge
+    def Iterations(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 1000
+
+    # AuthCraChallenge
+    def Keylen(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 32
+
+def AuthCraChallengeStart(builder): builder.StartObject(4)
+def Start(builder):
+    return AuthCraChallengeStart(builder)
+def AuthCraChallengeAddChallenge(builder, challenge): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(challenge), 0)
+def AddChallenge(builder, challenge):
+    return AuthCraChallengeAddChallenge(builder, challenge)
+def AuthCraChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
+def AddSalt(builder, salt):
+    return AuthCraChallengeAddSalt(builder, salt)
+def AuthCraChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(2, iterations, 1000)
+def AddIterations(builder, iterations):
+    return AuthCraChallengeAddIterations(builder, iterations)
+def AuthCraChallengeAddKeylen(builder, keylen): builder.PrependUint8Slot(3, keylen, 32)
+def AddKeylen(builder, keylen):
+    return AuthCraChallengeAddKeylen(builder, keylen)
+def AuthCraChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraRequest.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCraRequestStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCraRequestStart(builder)
+def AuthCraRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCraWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCraWelcomeStart(builder)
+def AuthCraWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignChallenge.py

@@ -0,0 +1,42 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCryptosignChallenge
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthCryptosignChallengeStart(builder): builder.StartObject(1)
+def Start(builder):
+    return AuthCryptosignChallengeStart(builder)
+def AuthCryptosignChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(0, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthCryptosignChallengeAddChannelBinding(builder, channelBinding)
+def AuthCryptosignChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignRequest.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCryptosignRequest
+    def Pubkey(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCryptosignRequest
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthCryptosignRequestStart(builder): builder.StartObject(2)
+def Start(builder):
+    return AuthCryptosignRequestStart(builder)
+def AuthCryptosignRequestAddPubkey(builder, pubkey): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pubkey), 0)
+def AddPubkey(builder, pubkey):
+    return AuthCryptosignRequestAddPubkey(builder, pubkey)
+def AuthCryptosignRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthCryptosignRequestAddChannelBinding(builder, channelBinding)
+def AuthCryptosignRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCryptosignWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCryptosignWelcomeStart(builder)
+def AuthCryptosignWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthFactor.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthFactor(object):
+    NONE = 0
+    AuthTicketRequest = 1
+    AuthCraRequest = 2
+    AuthScramRequest = 3
+    AuthCryptosignRequest = 4

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMethod.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthMethod(object):
+    ANONYMOUS = 0
+    COOKIE = 1
+    TLS = 2
+    TICKET = 3
+    CRA = 4
+    SCRAM = 5
+    CRYPTOSIGN = 6

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMode.py

@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthMode(object):
+    FIRST = 0
+    MULTIFACTOR = 1

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramChallenge.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramChallenge
+    def Nonce(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramChallenge
+    def Salt(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramChallenge
+    def Kdf(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 2
+
+    # AuthScramChallenge
+    def Iterations(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # AuthScramChallenge
+    def Memory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # AuthScramChallenge
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthScramChallengeStart(builder): builder.StartObject(6)
+def Start(builder):
+    return AuthScramChallengeStart(builder)
+def AuthScramChallengeAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
+def AddNonce(builder, nonce):
+    return AuthScramChallengeAddNonce(builder, nonce)
+def AuthScramChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
+def AddSalt(builder, salt):
+    return AuthScramChallengeAddSalt(builder, salt)
+def AuthScramChallengeAddKdf(builder, kdf): builder.PrependUint8Slot(2, kdf, 2)
+def AddKdf(builder, kdf):
+    return AuthScramChallengeAddKdf(builder, kdf)
+def AuthScramChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(3, iterations, 0)
+def AddIterations(builder, iterations):
+    return AuthScramChallengeAddIterations(builder, iterations)
+def AuthScramChallengeAddMemory(builder, memory): builder.PrependUint32Slot(4, memory, 0)
+def AddMemory(builder, memory):
+    return AuthScramChallengeAddMemory(builder, memory)
+def AuthScramChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(5, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthScramChallengeAddChannelBinding(builder, channelBinding)
+def AuthScramChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramRequest.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramRequest
+    def Nonce(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramRequest
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthScramRequestStart(builder): builder.StartObject(2)
+def Start(builder):
+    return AuthScramRequestStart(builder)
+def AuthScramRequestAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
+def AddNonce(builder, nonce):
+    return AuthScramRequestAddNonce(builder, nonce)
+def AuthScramRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthScramRequestAddChannelBinding(builder, channelBinding)
+def AuthScramRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramWelcome.py

@@ -0,0 +1,42 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramWelcome
+    def Verifier(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def AuthScramWelcomeStart(builder): builder.StartObject(1)
+def Start(builder):
+    return AuthScramWelcomeStart(builder)
+def AuthScramWelcomeAddVerifier(builder, verifier): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(verifier), 0)
+def AddVerifier(builder, verifier):
+    return AuthScramWelcomeAddVerifier(builder, verifier)
+def AuthScramWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketChallenge.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketChallengeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketChallengeStart(builder)
+def AuthTicketChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketRequest.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketRequestStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketRequestStart(builder)
+def AuthTicketRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketWelcomeStart(builder)
+def AuthTicketWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Authenticate.py

@@ -0,0 +1,66 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Authenticate(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Authenticate()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthenticate(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Authenticate
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Authenticate
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Authenticate
+    def Signature(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Authenticate
+    def Extra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def AuthenticateStart(builder): builder.StartObject(3)
+def Start(builder):
+    return AuthenticateStart(builder)
+def AuthenticateAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return AuthenticateAddSession(builder, session)
+def AuthenticateAddSignature(builder, signature): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(signature), 0)
+def AddSignature(builder, signature):
+    return AuthenticateAddSignature(builder, signature)
+def AuthenticateAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
+def AddExtra(builder, extra):
+    return AuthenticateAddExtra(builder, extra)
+def AuthenticateEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthenticateEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/BrokerFeatures.py

@@ -0,0 +1,172 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class BrokerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BrokerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBrokerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # BrokerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BrokerFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PublisherExclusion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriberBlackwhiteListing(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PatternBasedSubscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PublicationTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriptionRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SessionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriptionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def EventRetention(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def EventHistory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def AcknowledgeEventReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def AcknowledgeSubscriberReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def BrokerFeaturesStart(builder): builder.StartObject(14)
+def Start(builder):
+    return BrokerFeaturesStart(builder)
+def BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
+def AddPublisherExclusion(builder, publisherExclusion):
+    return BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion)
+def BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
+def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
+    return BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
+def BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(3, patternBasedSubscription, 0)
+def AddPatternBasedSubscription(builder, patternBasedSubscription):
+    return BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
+def BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(4, publicationTrustlevels, 0)
+def AddPublicationTrustlevels(builder, publicationTrustlevels):
+    return BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
+def BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(5, subscriptionRevocation, 0)
+def AddSubscriptionRevocation(builder, subscriptionRevocation):
+    return BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
+def BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(6, sessionMetaApi, 0)
+def AddSessionMetaApi(builder, sessionMetaApi):
+    return BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
+def BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi): builder.PrependBoolSlot(7, subscriptionMetaApi, 0)
+def AddSubscriptionMetaApi(builder, subscriptionMetaApi):
+    return BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi)
+def BrokerFeaturesAddEventRetention(builder, eventRetention): builder.PrependBoolSlot(8, eventRetention, 0)
+def AddEventRetention(builder, eventRetention):
+    return BrokerFeaturesAddEventRetention(builder, eventRetention)
+def BrokerFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(9, eventHistory, 0)
+def AddEventHistory(builder, eventHistory):
+    return BrokerFeaturesAddEventHistory(builder, eventHistory)
+def BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(10, acknowledgeEventReceived, 0)
+def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
+    return BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
+def BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(11, acknowledgeSubscriberReceived, 0)
+def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
+    return BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
+def BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(12, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(13, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def BrokerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return BrokerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Call.py

@@ -0,0 +1,238 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Call(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Call()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCall(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Call
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Call
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Call
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Call
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Call
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Call
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Call
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Call
+    def Timeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def ReceiveProgress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Call
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def CallerAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def CallerAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Call
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+def CallStart(builder): builder.StartObject(14)
+def Start(builder):
+    return CallStart(builder)
+def CallAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return CallAddSession(builder, session)
+def CallAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return CallAddRequest(builder, request)
+def CallAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return CallAddProcedure(builder, procedure)
+def CallAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return CallAddPayload(builder, payload)
+def CallStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return CallStartPayloadVector(builder, numElems)
+def CallAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return CallAddEncAlgo(builder, encAlgo)
+def CallAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return CallAddEncSerializer(builder, encSerializer)
+def CallAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return CallAddEncKey(builder, encKey)
+def CallStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return CallStartEncKeyVector(builder, numElems)
+def CallAddTimeout(builder, timeout): builder.PrependUint32Slot(7, timeout, 0)
+def AddTimeout(builder, timeout):
+    return CallAddTimeout(builder, timeout)
+def CallAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(8, receiveProgress, 0)
+def AddReceiveProgress(builder, receiveProgress):
+    return CallAddReceiveProgress(builder, receiveProgress)
+def CallAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return CallAddTransactionHash(builder, transactionHash)
+def CallAddCaller(builder, caller): builder.PrependUint64Slot(10, caller, 0)
+def AddCaller(builder, caller):
+    return CallAddCaller(builder, caller)
+def CallAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
+def AddCallerAuthid(builder, callerAuthid):
+    return CallAddCallerAuthid(builder, callerAuthid)
+def CallAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
+def AddCallerAuthrole(builder, callerAuthrole):
+    return CallAddCallerAuthrole(builder, callerAuthrole)
+def CallAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return CallAddForwardFor(builder, forwardFor)
+def CallStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return CallStartForwardForVector(builder, numElems)
+def CallEnd(builder): return builder.EndObject()
+def End(builder):
+    return CallEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CalleeFeatures.py

@@ -0,0 +1,132 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CalleeFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CalleeFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCalleeFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # CalleeFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CalleeFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def RegistrationRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PatternBasedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def SharedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def CalleeFeaturesStart(builder): builder.StartObject(10)
+def Start(builder):
+    return CalleeFeaturesStart(builder)
+def CalleeFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return CalleeFeaturesAddCallerIdentification(builder, callerIdentification)
+def CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
+def AddCallTrustlevels(builder, callTrustlevels):
+    return CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels)
+def CalleeFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return CalleeFeaturesAddCallTimeout(builder, callTimeout)
+def CalleeFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return CalleeFeaturesAddCallCanceling(builder, callCanceling)
+def CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
+def AddRegistrationRevocation(builder, registrationRevocation):
+    return CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation)
+def CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
+def AddPatternBasedRegistration(builder, patternBasedRegistration):
+    return CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
+def CalleeFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
+def AddSharedRegistration(builder, sharedRegistration):
+    return CalleeFeaturesAddSharedRegistration(builder, sharedRegistration)
+def CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(8, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(9, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def CalleeFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return CalleeFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CallerFeatures.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CallerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CallerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCallerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # CallerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CallerFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def CallerFeaturesStart(builder): builder.StartObject(6)
+def Start(builder):
+    return CallerFeaturesStart(builder)
+def CallerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return CallerFeaturesAddCallerIdentification(builder, callerIdentification)
+def CallerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(1, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return CallerFeaturesAddCallTimeout(builder, callTimeout)
+def CallerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(2, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return CallerFeaturesAddCallCanceling(builder, callCanceling)
+def CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(3, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def CallerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return CallerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def CallerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return CallerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Cancel.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Cancel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Cancel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCancel(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Cancel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Cancel
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def Mode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Cancel
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Cancel
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+def CancelStart(builder): builder.StartObject(4)
+def Start(builder):
+    return CancelStart(builder)
+def CancelAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return CancelAddSession(builder, session)
+def CancelAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return CancelAddRequest(builder, request)
+def CancelAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 0)
+def AddMode(builder, mode):
+    return CancelAddMode(builder, mode)
+def CancelAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return CancelAddForwardFor(builder, forwardFor)
+def CancelStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return CancelStartForwardForVector(builder, numElems)
+def CancelEnd(builder): return builder.EndObject()
+def End(builder):
+    return CancelEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CancelMode.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class CancelMode(object):
+    SKIP = 0
+    ABORT = 1
+    KILL = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Challenge.py

@@ -0,0 +1,66 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Challenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Challenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Challenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Challenge
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Challenge
+    def Method(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Challenge
+    def Extra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ChallengeStart(builder): builder.StartObject(3)
+def Start(builder):
+    return ChallengeStart(builder)
+def ChallengeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ChallengeAddSession(builder, session)
+def ChallengeAddMethod(builder, method): builder.PrependUint8Slot(1, method, 0)
+def AddMethod(builder, method):
+    return ChallengeAddMethod(builder, method)
+def ChallengeAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
+def AddExtra(builder, extra):
+    return ChallengeAddExtra(builder, extra)
+def ChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return ChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ChannelBinding.py

@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class ChannelBinding(object):
+    NONE = 0
+    TLS_UNIQUE = 1

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ClientRoles.py

@@ -0,0 +1,88 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ClientRoles(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ClientRoles()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsClientRoles(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # ClientRoles
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ClientRoles
+    def Publisher(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.PublisherFeatures import PublisherFeatures
+            obj = PublisherFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Subscriber(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.SubscriberFeatures import SubscriberFeatures
+            obj = SubscriberFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.CallerFeatures import CallerFeatures
+            obj = CallerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.CalleeFeatures import CalleeFeatures
+            obj = CalleeFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ClientRolesStart(builder): builder.StartObject(4)
+def Start(builder):
+    return ClientRolesStart(builder)
+def ClientRolesAddPublisher(builder, publisher): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(publisher), 0)
+def AddPublisher(builder, publisher):
+    return ClientRolesAddPublisher(builder, publisher)
+def ClientRolesAddSubscriber(builder, subscriber): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(subscriber), 0)
+def AddSubscriber(builder, subscriber):
+    return ClientRolesAddSubscriber(builder, subscriber)
+def ClientRolesAddCaller(builder, caller): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(caller), 0)
+def AddCaller(builder, caller):
+    return ClientRolesAddCaller(builder, caller)
+def ClientRolesAddCallee(builder, callee): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(callee), 0)
+def AddCallee(builder, callee):
+    return ClientRolesAddCallee(builder, callee)
+def ClientRolesEnd(builder): return builder.EndObject()
+def End(builder):
+    return ClientRolesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/DealerFeatures.py

@@ -0,0 +1,162 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DealerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DealerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsDealerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # DealerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DealerFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def RegistrationRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PatternBasedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def SharedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def SessionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def RegistrationMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def TestamentMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def DealerFeaturesStart(builder): builder.StartObject(13)
+def Start(builder):
+    return DealerFeaturesStart(builder)
+def DealerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return DealerFeaturesAddCallerIdentification(builder, callerIdentification)
+def DealerFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
+def AddCallTrustlevels(builder, callTrustlevels):
+    return DealerFeaturesAddCallTrustlevels(builder, callTrustlevels)
+def DealerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return DealerFeaturesAddCallTimeout(builder, callTimeout)
+def DealerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return DealerFeaturesAddCallCanceling(builder, callCanceling)
+def DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
+def AddRegistrationRevocation(builder, registrationRevocation):
+    return DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation)
+def DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
+def AddPatternBasedRegistration(builder, patternBasedRegistration):
+    return DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
+def DealerFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
+def AddSharedRegistration(builder, sharedRegistration):
+    return DealerFeaturesAddSharedRegistration(builder, sharedRegistration)
+def DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(8, sessionMetaApi, 0)
+def AddSessionMetaApi(builder, sessionMetaApi):
+    return DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
+def DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi): builder.PrependBoolSlot(9, registrationMetaApi, 0)
+def AddRegistrationMetaApi(builder, registrationMetaApi):
+    return DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi)
+def DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi): builder.PrependBoolSlot(10, testamentMetaApi, 0)
+def AddTestamentMetaApi(builder, testamentMetaApi):
+    return DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi)
+def DealerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(11, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return DealerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(12, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def DealerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return DealerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Error.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Error(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Error()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsError(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Error
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Error
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def RequestType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def Error(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Error
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Error
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Error
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Error
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Error
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Error
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Error
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Error
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+def ErrorStart(builder): builder.StartObject(8)
+def Start(builder):
+    return ErrorStart(builder)
+def ErrorAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ErrorAddSession(builder, session)
+def ErrorAddRequestType(builder, requestType): builder.PrependUint16Slot(1, requestType, 0)
+def AddRequestType(builder, requestType):
+    return ErrorAddRequestType(builder, requestType)
+def ErrorAddRequest(builder, request): builder.PrependUint64Slot(2, request, 0)
+def AddRequest(builder, request):
+    return ErrorAddRequest(builder, request)
+def ErrorAddError(builder, error): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(error), 0)
+def AddError(builder, error):
+    return ErrorAddError(builder, error)
+def ErrorAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return ErrorAddPayload(builder, payload)
+def ErrorStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return ErrorStartPayloadVector(builder, numElems)
+def ErrorAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return ErrorAddEncAlgo(builder, encAlgo)
+def ErrorAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return ErrorAddEncSerializer(builder, encSerializer)
+def ErrorAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return ErrorAddEncKey(builder, encKey)
+def ErrorStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return ErrorStartEncKeyVector(builder, numElems)
+def ErrorEnd(builder): return builder.EndObject()
+def End(builder):
+    return ErrorEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Event.py

@@ -0,0 +1,317 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Event(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Event()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEvent(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Event
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Event
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Positional values for application-defined event payload.
+    # Event
+    def Args(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def ArgsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def ArgsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def ArgsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Keyword values for application-defined event payload.
+    # Event
+    def Kwargs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def KwargsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def KwargsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def KwargsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
+    # Event
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Event
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Event
+    def Publisher(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def PublisherAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def PublisherAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Retained(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Event
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Acknowledge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Event
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Event
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+def EventStart(builder): builder.StartObject(17)
+def Start(builder):
+    return EventStart(builder)
+def EventAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return EventAddSession(builder, session)
+def EventAddSubscription(builder, subscription): builder.PrependUint64Slot(1, subscription, 0)
+def AddSubscription(builder, subscription):
+    return EventAddSubscription(builder, subscription)
+def EventAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
+def AddPublication(builder, publication):
+    return EventAddPublication(builder, publication)
+def EventAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
+def AddArgs(builder, args):
+    return EventAddArgs(builder, args)
+def EventStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartArgsVector(builder, numElems):
+    return EventStartArgsVector(builder, numElems)
+def EventAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
+def AddKwargs(builder, kwargs):
+    return EventAddKwargs(builder, kwargs)
+def EventStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartKwargsVector(builder, numElems):
+    return EventStartKwargsVector(builder, numElems)
+def EventAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return EventAddPayload(builder, payload)
+def EventStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return EventStartPayloadVector(builder, numElems)
+def EventAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return EventAddEncAlgo(builder, encAlgo)
+def EventAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return EventAddEncSerializer(builder, encSerializer)
+def EventAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return EventAddEncKey(builder, encKey)
+def EventStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return EventStartEncKeyVector(builder, numElems)
+def EventAddPublisher(builder, publisher): builder.PrependUint64Slot(9, publisher, 0)
+def AddPublisher(builder, publisher):
+    return EventAddPublisher(builder, publisher)
+def EventAddPublisherAuthid(builder, publisherAuthid): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthid), 0)
+def AddPublisherAuthid(builder, publisherAuthid):
+    return EventAddPublisherAuthid(builder, publisherAuthid)
+def EventAddPublisherAuthrole(builder, publisherAuthrole): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthrole), 0)
+def AddPublisherAuthrole(builder, publisherAuthrole):
+    return EventAddPublisherAuthrole(builder, publisherAuthrole)
+def EventAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return EventAddTopic(builder, topic)
+def EventAddRetained(builder, retained): builder.PrependBoolSlot(13, retained, 0)
+def AddRetained(builder, retained):
+    return EventAddRetained(builder, retained)
+def EventAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return EventAddTransactionHash(builder, transactionHash)
+def EventAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(15, acknowledge, 0)
+def AddAcknowledge(builder, acknowledge):
+    return EventAddAcknowledge(builder, acknowledge)
+def EventAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return EventAddForwardFor(builder, forwardFor)
+def EventStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return EventStartForwardForVector(builder, numElems)
+def EventEnd(builder): return builder.EndObject()
+def End(builder):
+    return EventEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/EventReceived.py

@@ -0,0 +1,138 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class EventReceived(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EventReceived()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEventReceived(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # EventReceived
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # EventReceived
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # EventReceived
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # EventReceived
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EventReceived
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # EventReceived
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # EventReceived
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # EventReceived
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EventReceived
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+def EventReceivedStart(builder): builder.StartObject(6)
+def Start(builder):
+    return EventReceivedStart(builder)
+def EventReceivedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return EventReceivedAddSession(builder, session)
+def EventReceivedAddPublication(builder, publication): builder.PrependUint64Slot(1, publication, 0)
+def AddPublication(builder, publication):
+    return EventReceivedAddPublication(builder, publication)
+def EventReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return EventReceivedAddPayload(builder, payload)
+def EventReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return EventReceivedStartPayloadVector(builder, numElems)
+def EventReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return EventReceivedAddEncAlgo(builder, encAlgo)
+def EventReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return EventReceivedAddEncSerializer(builder, encSerializer)
+def EventReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return EventReceivedAddEncKey(builder, encKey)
+def EventReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return EventReceivedStartEncKeyVector(builder, numElems)
+def EventReceivedEnd(builder): return builder.EndObject()
+def End(builder):
+    return EventReceivedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Goodbye.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Goodbye(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Goodbye()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsGoodbye(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Goodbye
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Goodbye
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Goodbye
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Goodbye
+    def Message(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Goodbye
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def GoodbyeStart(builder): builder.StartObject(4)
+def Start(builder):
+    return GoodbyeStart(builder)
+def GoodbyeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return GoodbyeAddSession(builder, session)
+def GoodbyeAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return GoodbyeAddReason(builder, reason)
+def GoodbyeAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+def AddMessage(builder, message):
+    return GoodbyeAddMessage(builder, message)
+def GoodbyeAddResumable(builder, resumable): builder.PrependBoolSlot(3, resumable, 0)
+def AddResumable(builder, resumable):
+    return GoodbyeAddResumable(builder, resumable)
+def GoodbyeEnd(builder): return builder.EndObject()
+def End(builder):
+    return GoodbyeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Hello.py

@@ -0,0 +1,163 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Hello(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Hello()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHello(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Hello
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Hello
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Hello
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.ClientRoles import ClientRoles
+            obj = ClientRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Hello
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authmethods(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Hello
+    def AuthmethodsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Hello
+    def AuthmethodsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Hello
+    def AuthmethodsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Hello
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authextra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Hello
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Hello
+    def ResumeSession(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Hello
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloStart(builder): builder.StartObject(10)
+def Start(builder):
+    return HelloStart(builder)
+def HelloAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return HelloAddSession(builder, session)
+def HelloAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return HelloAddRoles(builder, roles)
+def HelloAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return HelloAddRealm(builder, realm)
+def HelloAddAuthmethods(builder, authmethods): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authmethods), 0)
+def AddAuthmethods(builder, authmethods):
+    return HelloAddAuthmethods(builder, authmethods)
+def HelloStartAuthmethodsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartAuthmethodsVector(builder, numElems):
+    return HelloStartAuthmethodsVector(builder, numElems)
+def HelloAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return HelloAddAuthid(builder, authid)
+def HelloAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return HelloAddAuthrole(builder, authrole)
+def HelloAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
+def AddAuthextra(builder, authextra):
+    return HelloAddAuthextra(builder, authextra)
+def HelloAddResumable(builder, resumable): builder.PrependBoolSlot(7, resumable, 0)
+def AddResumable(builder, resumable):
+    return HelloAddResumable(builder, resumable)
+def HelloAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(8, resumeSession, 0)
+def AddResumeSession(builder, resumeSession):
+    return HelloAddResumeSession(builder, resumeSession)
+def HelloAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return HelloAddResumeToken(builder, resumeToken)
+def HelloEnd(builder): return builder.EndObject()
+def End(builder):
+    return HelloEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/HelloNew.py

@@ -0,0 +1,185 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class HelloNew(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloNew()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHelloNew(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloNew
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # HelloNew
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.ClientRoles import ClientRoles
+            obj = ClientRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # HelloNew
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authmode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor1Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Authfactor2Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Authfactor3Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor3(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # HelloNew
+    def ResumeSession(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloNewStart(builder): builder.StartObject(14)
+def Start(builder):
+    return HelloNewStart(builder)
+def HelloNewAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return HelloNewAddRoles(builder, roles)
+def HelloNewAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return HelloNewAddRealm(builder, realm)
+def HelloNewAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return HelloNewAddAuthid(builder, authid)
+def HelloNewAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return HelloNewAddAuthrole(builder, authrole)
+def HelloNewAddAuthmode(builder, authmode): builder.PrependUint8Slot(4, authmode, 0)
+def AddAuthmode(builder, authmode):
+    return HelloNewAddAuthmode(builder, authmode)
+def HelloNewAddAuthfactor1Type(builder, authfactor1Type): builder.PrependUint8Slot(5, authfactor1Type, 0)
+def AddAuthfactor1Type(builder, authfactor1Type):
+    return HelloNewAddAuthfactor1Type(builder, authfactor1Type)
+def HelloNewAddAuthfactor1(builder, authfactor1): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor1), 0)
+def AddAuthfactor1(builder, authfactor1):
+    return HelloNewAddAuthfactor1(builder, authfactor1)
+def HelloNewAddAuthfactor2Type(builder, authfactor2Type): builder.PrependUint8Slot(7, authfactor2Type, 0)
+def AddAuthfactor2Type(builder, authfactor2Type):
+    return HelloNewAddAuthfactor2Type(builder, authfactor2Type)
+def HelloNewAddAuthfactor2(builder, authfactor2): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor2), 0)
+def AddAuthfactor2(builder, authfactor2):
+    return HelloNewAddAuthfactor2(builder, authfactor2)
+def HelloNewAddAuthfactor3Type(builder, authfactor3Type): builder.PrependUint8Slot(9, authfactor3Type, 0)
+def AddAuthfactor3Type(builder, authfactor3Type):
+    return HelloNewAddAuthfactor3Type(builder, authfactor3Type)
+def HelloNewAddAuthfactor3(builder, authfactor3): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor3), 0)
+def AddAuthfactor3(builder, authfactor3):
+    return HelloNewAddAuthfactor3(builder, authfactor3)
+def HelloNewAddResumable(builder, resumable): builder.PrependBoolSlot(11, resumable, 0)
+def AddResumable(builder, resumable):
+    return HelloNewAddResumable(builder, resumable)
+def HelloNewAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(12, resumeSession, 0)
+def AddResumeSession(builder, resumeSession):
+    return HelloNewAddResumeSession(builder, resumeSession)
+def HelloNewAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return HelloNewAddResumeToken(builder, resumeToken)
+def HelloNewEnd(builder): return builder.EndObject()
+def End(builder):
+    return HelloNewEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Interrupt.py

@@ -0,0 +1,102 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Interrupt(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Interrupt()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInterrupt(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Interrupt
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Interrupt
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Interrupt
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Interrupt
+    def Mode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 1
+
+    # Interrupt
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Interrupt
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Interrupt
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Interrupt
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def InterruptStart(builder): builder.StartObject(5)
+def Start(builder):
+    return InterruptStart(builder)
+def InterruptAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return InterruptAddSession(builder, session)
+def InterruptAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return InterruptAddRequest(builder, request)
+def InterruptAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 1)
+def AddMode(builder, mode):
+    return InterruptAddMode(builder, mode)
+def InterruptAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return InterruptAddReason(builder, reason)
+def InterruptAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return InterruptAddForwardFor(builder, forwardFor)
+def InterruptStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return InterruptStartForwardForVector(builder, numElems)
+def InterruptEnd(builder): return builder.EndObject()
+def End(builder):
+    return InterruptEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Invocation.py

@@ -0,0 +1,248 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Invocation(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Invocation()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInvocation(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Invocation
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Invocation
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Invocation
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Invocation
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Invocation
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Invocation
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Invocation
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Invocation
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def Timeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def ReceiveProgress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Invocation
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def CallerAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def CallerAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Invocation
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+def InvocationStart(builder): builder.StartObject(15)
+def Start(builder):
+    return InvocationStart(builder)
+def InvocationAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return InvocationAddSession(builder, session)
+def InvocationAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return InvocationAddRequest(builder, request)
+def InvocationAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return InvocationAddRegistration(builder, registration)
+def InvocationAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return InvocationAddPayload(builder, payload)
+def InvocationStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return InvocationStartPayloadVector(builder, numElems)
+def InvocationAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return InvocationAddEncAlgo(builder, encAlgo)
+def InvocationAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return InvocationAddEncSerializer(builder, encSerializer)
+def InvocationAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return InvocationAddEncKey(builder, encKey)
+def InvocationStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return InvocationStartEncKeyVector(builder, numElems)
+def InvocationAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return InvocationAddProcedure(builder, procedure)
+def InvocationAddTimeout(builder, timeout): builder.PrependUint32Slot(8, timeout, 0)
+def AddTimeout(builder, timeout):
+    return InvocationAddTimeout(builder, timeout)
+def InvocationAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(9, receiveProgress, 0)
+def AddReceiveProgress(builder, receiveProgress):
+    return InvocationAddReceiveProgress(builder, receiveProgress)
+def InvocationAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return InvocationAddTransactionHash(builder, transactionHash)
+def InvocationAddCaller(builder, caller): builder.PrependUint64Slot(11, caller, 0)
+def AddCaller(builder, caller):
+    return InvocationAddCaller(builder, caller)
+def InvocationAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
+def AddCallerAuthid(builder, callerAuthid):
+    return InvocationAddCallerAuthid(builder, callerAuthid)
+def InvocationAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
+def AddCallerAuthrole(builder, callerAuthrole):
+    return InvocationAddCallerAuthrole(builder, callerAuthrole)
+def InvocationAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return InvocationAddForwardFor(builder, forwardFor)
+def InvocationStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return InvocationStartForwardForVector(builder, numElems)
+def InvocationEnd(builder): return builder.EndObject()
+def End(builder):
+    return InvocationEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/InvocationPolicy.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class InvocationPolicy(object):
+    SINGLE = 0
+    FIRST = 1
+    LAST = 2
+    ROUNDROBIN = 3
+    RANDOM = 4

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Kdf.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Kdf(object):
+    NONE = 0
+    PBKDF2 = 1
+    ARGON2 = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Match.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Match(object):
+    EXACT = 0
+    PREFIX = 1
+    WILDCARD = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Message.py

@@ -0,0 +1,55 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Message(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Message()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMessage(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Message
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Message
+    def MsgType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Message
+    def Msg(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+def MessageStart(builder): builder.StartObject(2)
+def Start(builder):
+    return MessageStart(builder)
+def MessageAddMsgType(builder, msgType): builder.PrependUint8Slot(0, msgType, 0)
+def AddMsgType(builder, msgType):
+    return MessageAddMsgType(builder, msgType)
+def MessageAddMsg(builder, msg): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(msg), 0)
+def AddMsg(builder, msg):
+    return MessageAddMsg(builder, msg)
+def MessageEnd(builder): return builder.EndObject()
+def End(builder):
+    return MessageEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/MessageType.py

@@ -0,0 +1,31 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class MessageType(object):
+    NULL = 0
+    HELLO = 1
+    WELCOME = 2
+    ABORT = 3
+    CHALLENGE = 4
+    AUTHENTICATE = 5
+    GOODBYE = 6
+    ERROR = 8
+    PUBLISH = 16
+    PUBLISHED = 17
+    SUBSCRIBE = 32
+    SUBSCRIBED = 33
+    UNSUBSCRIBE = 34
+    UNSUBSCRIBED = 35
+    EVENT = 36
+    EVENT_RECEIVED = 37
+    CALL = 48
+    CANCEL = 49
+    RESULT = 50
+    REGISTER = 64
+    REGISTERED = 65
+    UNREGISTER = 66
+    UNREGISTERED = 67
+    INVOCATION = 68
+    INTERRUPT = 69
+    YIELD = 70

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Payload.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Payload(object):
+    PLAIN = 0
+    CRYPTOBOX = 1
+    OPAQUE = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Principal.py

@@ -0,0 +1,26 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Principal(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 8
+
+    # Principal
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Principal
+    def Session(self): return self._tab.Get(flatbuffers.number_types.Uint64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+
+def CreatePrincipal(builder, session):
+    builder.Prep(8, 8)
+    builder.PrependUint64(session)
+    return builder.Offset()

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Publish.py

@@ -0,0 +1,457 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Publish(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Publish()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublish(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Publish
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Publish
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Positional values for application-defined event payload.
+    # Publish
+    def Args(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def ArgsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def ArgsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ArgsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Keyword values for application-defined event payload.
+    # Publish
+    def Kwargs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def KwargsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def KwargsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def KwargsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
+    # Publish
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Publish
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Publish
+    def Acknowledge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Publish
+    def ExcludeMe(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # Publish
+    def Exclude(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Publish
+    def ExcludeAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+        return 0
+
+    # Publish
+    def ExcludeLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # Publish
+    def ExcludeAuthid(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def ExcludeAuthidLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeAuthidIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        return o == 0
+
+    # Publish
+    def ExcludeAuthrole(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def ExcludeAuthroleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeAuthroleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # Publish
+    def Eligible(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Publish
+    def EligibleAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+        return 0
+
+    # Publish
+    def EligibleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+    # Publish
+    def EligibleAuthid(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def EligibleAuthidLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleAuthidIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        return o == 0
+
+    # Publish
+    def EligibleAuthrole(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def EligibleAuthroleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleAuthroleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+    # Publish
+    def Retain(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Publish
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Publish
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Publish
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        return o == 0
+
+def PublishStart(builder): builder.StartObject(20)
+def Start(builder):
+    return PublishStart(builder)
+def PublishAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return PublishAddSession(builder, session)
+def PublishAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return PublishAddRequest(builder, request)
+def PublishAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return PublishAddTopic(builder, topic)
+def PublishAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
+def AddArgs(builder, args):
+    return PublishAddArgs(builder, args)
+def PublishStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartArgsVector(builder, numElems):
+    return PublishStartArgsVector(builder, numElems)
+def PublishAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
+def AddKwargs(builder, kwargs):
+    return PublishAddKwargs(builder, kwargs)
+def PublishStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartKwargsVector(builder, numElems):
+    return PublishStartKwargsVector(builder, numElems)
+def PublishAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return PublishAddPayload(builder, payload)
+def PublishStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return PublishStartPayloadVector(builder, numElems)
+def PublishAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return PublishAddEncAlgo(builder, encAlgo)
+def PublishAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return PublishAddEncSerializer(builder, encSerializer)
+def PublishAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return PublishAddEncKey(builder, encKey)
+def PublishStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return PublishStartEncKeyVector(builder, numElems)
+def PublishAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(9, acknowledge, 0)
+def AddAcknowledge(builder, acknowledge):
+    return PublishAddAcknowledge(builder, acknowledge)
+def PublishAddExcludeMe(builder, excludeMe): builder.PrependBoolSlot(10, excludeMe, 1)
+def AddExcludeMe(builder, excludeMe):
+    return PublishAddExcludeMe(builder, excludeMe)
+def PublishAddExclude(builder, exclude): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(exclude), 0)
+def AddExclude(builder, exclude):
+    return PublishAddExclude(builder, exclude)
+def PublishStartExcludeVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartExcludeVector(builder, numElems):
+    return PublishStartExcludeVector(builder, numElems)
+def PublishAddExcludeAuthid(builder, excludeAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthid), 0)
+def AddExcludeAuthid(builder, excludeAuthid):
+    return PublishAddExcludeAuthid(builder, excludeAuthid)
+def PublishStartExcludeAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartExcludeAuthidVector(builder, numElems):
+    return PublishStartExcludeAuthidVector(builder, numElems)
+def PublishAddExcludeAuthrole(builder, excludeAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthrole), 0)
+def AddExcludeAuthrole(builder, excludeAuthrole):
+    return PublishAddExcludeAuthrole(builder, excludeAuthrole)
+def PublishStartExcludeAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartExcludeAuthroleVector(builder, numElems):
+    return PublishStartExcludeAuthroleVector(builder, numElems)
+def PublishAddEligible(builder, eligible): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(eligible), 0)
+def AddEligible(builder, eligible):
+    return PublishAddEligible(builder, eligible)
+def PublishStartEligibleVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartEligibleVector(builder, numElems):
+    return PublishStartEligibleVector(builder, numElems)
+def PublishAddEligibleAuthid(builder, eligibleAuthid): builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthid), 0)
+def AddEligibleAuthid(builder, eligibleAuthid):
+    return PublishAddEligibleAuthid(builder, eligibleAuthid)
+def PublishStartEligibleAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartEligibleAuthidVector(builder, numElems):
+    return PublishStartEligibleAuthidVector(builder, numElems)
+def PublishAddEligibleAuthrole(builder, eligibleAuthrole): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthrole), 0)
+def AddEligibleAuthrole(builder, eligibleAuthrole):
+    return PublishAddEligibleAuthrole(builder, eligibleAuthrole)
+def PublishStartEligibleAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartEligibleAuthroleVector(builder, numElems):
+    return PublishStartEligibleAuthroleVector(builder, numElems)
+def PublishAddRetain(builder, retain): builder.PrependBoolSlot(17, retain, 0)
+def AddRetain(builder, retain):
+    return PublishAddRetain(builder, retain)
+def PublishAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return PublishAddTransactionHash(builder, transactionHash)
+def PublishAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return PublishAddForwardFor(builder, forwardFor)
+def PublishStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return PublishStartForwardForVector(builder, numElems)
+def PublishEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublishEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Published.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Published(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Published()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublished(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Published
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Published
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Published
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Published
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def PublishedStart(builder): builder.StartObject(3)
+def Start(builder):
+    return PublishedStart(builder)
+def PublishedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return PublishedAddSession(builder, session)
+def PublishedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return PublishedAddRequest(builder, request)
+def PublishedAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
+def AddPublication(builder, publication):
+    return PublishedAddPublication(builder, publication)
+def PublishedEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublishedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/PublisherFeatures.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class PublisherFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = PublisherFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublisherFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # PublisherFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # PublisherFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PublisherExclusion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def SubscriberBlackwhiteListing(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def AcknowledgeEventReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def PublisherFeaturesStart(builder): builder.StartObject(6)
+def Start(builder):
+    return PublisherFeaturesStart(builder)
+def PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
+def AddPublisherExclusion(builder, publisherExclusion):
+    return PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion)
+def PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
+def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
+    return PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
+def PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(3, acknowledgeEventReceived, 0)
+def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
+    return PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
+def PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def PublisherFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublisherFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Register.py

@@ -0,0 +1,102 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Register(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Register()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRegister(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Register
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Register
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Register
+    def Match(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Invoke(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Concurrency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def ForceReregister(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def RegisterStart(builder): builder.StartObject(7)
+def Start(builder):
+    return RegisterStart(builder)
+def RegisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return RegisterAddSession(builder, session)
+def RegisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return RegisterAddRequest(builder, request)
+def RegisterAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return RegisterAddProcedure(builder, procedure)
+def RegisterAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
+def AddMatch(builder, match):
+    return RegisterAddMatch(builder, match)
+def RegisterAddInvoke(builder, invoke): builder.PrependUint8Slot(4, invoke, 0)
+def AddInvoke(builder, invoke):
+    return RegisterAddInvoke(builder, invoke)
+def RegisterAddConcurrency(builder, concurrency): builder.PrependUint16Slot(5, concurrency, 0)
+def AddConcurrency(builder, concurrency):
+    return RegisterAddConcurrency(builder, concurrency)
+def RegisterAddForceReregister(builder, forceReregister): builder.PrependBoolSlot(6, forceReregister, 0)
+def AddForceReregister(builder, forceReregister):
+    return RegisterAddForceReregister(builder, forceReregister)
+def RegisterEnd(builder): return builder.EndObject()
+def End(builder):
+    return RegisterEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Registered.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Registered(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Registered()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRegistered(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Registered
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Registered
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Registered
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Registered
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def RegisteredStart(builder): builder.StartObject(3)
+def Start(builder):
+    return RegisteredStart(builder)
+def RegisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return RegisteredAddSession(builder, session)
+def RegisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return RegisteredAddRequest(builder, request)
+def RegisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return RegisteredAddRegistration(builder, registration)
+def RegisteredEnd(builder): return builder.EndObject()
+def End(builder):
+    return RegisteredEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Result.py

@@ -0,0 +1,208 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Result(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Result()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsResult(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Result
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Result
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Result
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Result
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Result
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Result
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Result
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Result
+    def Progress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Result
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def CalleeAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Result
+    def CalleeAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Result
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Result
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+def ResultStart(builder): builder.StartObject(11)
+def Start(builder):
+    return ResultStart(builder)
+def ResultAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ResultAddSession(builder, session)
+def ResultAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return ResultAddRequest(builder, request)
+def ResultAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return ResultAddPayload(builder, payload)
+def ResultStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return ResultStartPayloadVector(builder, numElems)
+def ResultAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return ResultAddEncAlgo(builder, encAlgo)
+def ResultAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return ResultAddEncSerializer(builder, encSerializer)
+def ResultAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return ResultAddEncKey(builder, encKey)
+def ResultStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return ResultStartEncKeyVector(builder, numElems)
+def ResultAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
+def AddProgress(builder, progress):
+    return ResultAddProgress(builder, progress)
+def ResultAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
+def AddCallee(builder, callee):
+    return ResultAddCallee(builder, callee)
+def ResultAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
+def AddCalleeAuthid(builder, calleeAuthid):
+    return ResultAddCalleeAuthid(builder, calleeAuthid)
+def ResultAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
+def AddCalleeAuthrole(builder, calleeAuthrole):
+    return ResultAddCalleeAuthrole(builder, calleeAuthrole)
+def ResultAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return ResultAddForwardFor(builder, forwardFor)
+def ResultStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return ResultStartForwardForVector(builder, numElems)
+def ResultEnd(builder): return builder.EndObject()
+def End(builder):
+    return ResultEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/RouterRoles.py

@@ -0,0 +1,60 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class RouterRoles(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RouterRoles()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRouterRoles(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # RouterRoles
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # RouterRoles
+    def Broker(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.BrokerFeatures import BrokerFeatures
+            obj = BrokerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # RouterRoles
+    def Dealer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.DealerFeatures import DealerFeatures
+            obj = DealerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def RouterRolesStart(builder): builder.StartObject(2)
+def Start(builder):
+    return RouterRolesStart(builder)
+def RouterRolesAddBroker(builder, broker): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broker), 0)
+def AddBroker(builder, broker):
+    return RouterRolesAddBroker(builder, broker)
+def RouterRolesAddDealer(builder, dealer): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(dealer), 0)
+def AddDealer(builder, dealer):
+    return RouterRolesAddDealer(builder, dealer)
+def RouterRolesEnd(builder): return builder.EndObject()
+def End(builder):
+    return RouterRolesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Serializer.py

@@ -0,0 +1,13 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Serializer(object):
+    TRANSPORT = 0
+    JSON = 1
+    MSGPACK = 2
+    CBOR = 3
+    UBJSON = 4
+    OPAQUE = 5
+    FLATBUFFERS = 6
+    FLEXBUFFERS = 7

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribe.py

@@ -0,0 +1,82 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Subscribe(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Subscribe()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscribe(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Subscribe
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Subscribe
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Subscribe
+    def Match(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def GetRetained(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SubscribeStart(builder): builder.StartObject(5)
+def Start(builder):
+    return SubscribeStart(builder)
+def SubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return SubscribeAddSession(builder, session)
+def SubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return SubscribeAddRequest(builder, request)
+def SubscribeAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return SubscribeAddTopic(builder, topic)
+def SubscribeAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
+def AddMatch(builder, match):
+    return SubscribeAddMatch(builder, match)
+def SubscribeAddGetRetained(builder, getRetained): builder.PrependBoolSlot(4, getRetained, 0)
+def AddGetRetained(builder, getRetained):
+    return SubscribeAddGetRetained(builder, getRetained)
+def SubscribeEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscribeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribed.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Subscribed(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Subscribed()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscribed(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Subscribed
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Subscribed
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribed
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribed
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def SubscribedStart(builder): builder.StartObject(3)
+def Start(builder):
+    return SubscribedStart(builder)
+def SubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return SubscribedAddSession(builder, session)
+def SubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return SubscribedAddRequest(builder, request)
+def SubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return SubscribedAddSubscription(builder, subscription)
+def SubscribedEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscribedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberFeatures.py

@@ -0,0 +1,112 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class SubscriberFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SubscriberFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscriberFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SubscriberFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SubscriberFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PatternBasedSubscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PublicationTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def SubscriptionRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def EventHistory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def AcknowledgeSubscriberReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SubscriberFeaturesStart(builder): builder.StartObject(8)
+def Start(builder):
+    return SubscriberFeaturesStart(builder)
+def SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(1, patternBasedSubscription, 0)
+def AddPatternBasedSubscription(builder, patternBasedSubscription):
+    return SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
+def SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(2, publicationTrustlevels, 0)
+def AddPublicationTrustlevels(builder, publicationTrustlevels):
+    return SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
+def SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(3, subscriptionRevocation, 0)
+def AddSubscriptionRevocation(builder, subscriptionRevocation):
+    return SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
+def SubscriberFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(4, eventHistory, 0)
+def AddEventHistory(builder, eventHistory):
+    return SubscriberFeaturesAddEventHistory(builder, eventHistory)
+def SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(5, acknowledgeSubscriberReceived, 0)
+def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
+    return SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
+def SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(6, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(7, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def SubscriberFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscriberFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberReceived.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class SubscriberReceived(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SubscriberReceived()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscriberReceived(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SubscriberReceived
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SubscriberReceived
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def Subscriber(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def SubscriberAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # SubscriberReceived
+    def SubscriberAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # SubscriberReceived
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # SubscriberReceived
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # SubscriberReceived
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SubscriberReceived
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # SubscriberReceived
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # SubscriberReceived
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # SubscriberReceived
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SubscriberReceived
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+def SubscriberReceivedStart(builder): builder.StartObject(8)
+def Start(builder):
+    return SubscriberReceivedStart(builder)
+def SubscriberReceivedAddPublication(builder, publication): builder.PrependUint64Slot(0, publication, 0)
+def AddPublication(builder, publication):
+    return SubscriberReceivedAddPublication(builder, publication)
+def SubscriberReceivedAddSubscriber(builder, subscriber): builder.PrependUint64Slot(1, subscriber, 0)
+def AddSubscriber(builder, subscriber):
+    return SubscriberReceivedAddSubscriber(builder, subscriber)
+def SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthid), 0)
+def AddSubscriberAuthid(builder, subscriberAuthid):
+    return SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid)
+def SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthrole), 0)
+def AddSubscriberAuthrole(builder, subscriberAuthrole):
+    return SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole)
+def SubscriberReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return SubscriberReceivedAddPayload(builder, payload)
+def SubscriberReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return SubscriberReceivedStartPayloadVector(builder, numElems)
+def SubscriberReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return SubscriberReceivedAddEncAlgo(builder, encAlgo)
+def SubscriberReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return SubscriberReceivedAddEncSerializer(builder, encSerializer)
+def SubscriberReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return SubscriberReceivedAddEncKey(builder, encKey)
+def SubscriberReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return SubscriberReceivedStartEncKeyVector(builder, numElems)
+def SubscriberReceivedEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscriberReceivedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregister.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unregister(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unregister()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnregister(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unregister
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unregister
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregister
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregister
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def UnregisterStart(builder): builder.StartObject(3)
+def Start(builder):
+    return UnregisterStart(builder)
+def UnregisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnregisterAddSession(builder, session)
+def UnregisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnregisterAddRequest(builder, request)
+def UnregisterAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return UnregisterAddRegistration(builder, registration)
+def UnregisterEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnregisterEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregistered.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unregistered(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unregistered()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnregistered(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unregistered
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unregistered
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def UnregisteredStart(builder): builder.StartObject(4)
+def Start(builder):
+    return UnregisteredStart(builder)
+def UnregisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnregisteredAddSession(builder, session)
+def UnregisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnregisteredAddRequest(builder, request)
+def UnregisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return UnregisteredAddRegistration(builder, registration)
+def UnregisteredAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return UnregisteredAddReason(builder, reason)
+def UnregisteredEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnregisteredEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribe.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unsubscribe(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unsubscribe()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnsubscribe(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unsubscribe
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unsubscribe
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribe
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribe
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def UnsubscribeStart(builder): builder.StartObject(3)
+def Start(builder):
+    return UnsubscribeStart(builder)
+def UnsubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnsubscribeAddSession(builder, session)
+def UnsubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnsubscribeAddRequest(builder, request)
+def UnsubscribeAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return UnsubscribeAddSubscription(builder, subscription)
+def UnsubscribeEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnsubscribeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribed.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unsubscribed(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unsubscribed()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnsubscribed(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unsubscribed
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unsubscribed
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def UnsubscribedStart(builder): builder.StartObject(4)
+def Start(builder):
+    return UnsubscribedStart(builder)
+def UnsubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnsubscribedAddSession(builder, session)
+def UnsubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnsubscribedAddRequest(builder, request)
+def UnsubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return UnsubscribedAddSubscription(builder, subscription)
+def UnsubscribedAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return UnsubscribedAddReason(builder, reason)
+def UnsubscribedEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnsubscribedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Welcome.py

@@ -0,0 +1,150 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Welcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Welcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Welcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Welcome
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Welcome
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.RouterRoles import RouterRoles
+            obj = RouterRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Welcome
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authmethod(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Welcome
+    def Authprovider(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authextra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Welcome
+    def Resumed(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Welcome
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Welcome
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def WelcomeStart(builder): builder.StartObject(11)
+def Start(builder):
+    return WelcomeStart(builder)
+def WelcomeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return WelcomeAddSession(builder, session)
+def WelcomeAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return WelcomeAddRoles(builder, roles)
+def WelcomeAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return WelcomeAddRealm(builder, realm)
+def WelcomeAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return WelcomeAddAuthid(builder, authid)
+def WelcomeAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return WelcomeAddAuthrole(builder, authrole)
+def WelcomeAddAuthmethod(builder, authmethod): builder.PrependUint8Slot(5, authmethod, 0)
+def AddAuthmethod(builder, authmethod):
+    return WelcomeAddAuthmethod(builder, authmethod)
+def WelcomeAddAuthprovider(builder, authprovider): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authprovider), 0)
+def AddAuthprovider(builder, authprovider):
+    return WelcomeAddAuthprovider(builder, authprovider)
+def WelcomeAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
+def AddAuthextra(builder, authextra):
+    return WelcomeAddAuthextra(builder, authextra)
+def WelcomeAddResumed(builder, resumed): builder.PrependBoolSlot(8, resumed, 0)
+def AddResumed(builder, resumed):
+    return WelcomeAddResumed(builder, resumed)
+def WelcomeAddResumable(builder, resumable): builder.PrependBoolSlot(9, resumable, 0)
+def AddResumable(builder, resumable):
+    return WelcomeAddResumable(builder, resumable)
+def WelcomeAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return WelcomeAddResumeToken(builder, resumeToken)
+def WelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return WelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Yield.py

@@ -0,0 +1,208 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Yield(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Yield()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsYield(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Yield
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Yield
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Yield
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Yield
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Yield
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Yield
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Yield
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Yield
+    def Progress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Yield
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def CalleeAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Yield
+    def CalleeAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Yield
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Yield
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+def YieldStart(builder): builder.StartObject(11)
+def Start(builder):
+    return YieldStart(builder)
+def YieldAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return YieldAddSession(builder, session)
+def YieldAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return YieldAddRequest(builder, request)
+def YieldAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return YieldAddPayload(builder, payload)
+def YieldStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return YieldStartPayloadVector(builder, numElems)
+def YieldAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return YieldAddEncAlgo(builder, encAlgo)
+def YieldAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return YieldAddEncSerializer(builder, encSerializer)
+def YieldAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return YieldAddEncKey(builder, encKey)
+def YieldStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return YieldStartEncKeyVector(builder, numElems)
+def YieldAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
+def AddProgress(builder, progress):
+    return YieldAddProgress(builder, progress)
+def YieldAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
+def AddCallee(builder, callee):
+    return YieldAddCallee(builder, callee)
+def YieldAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
+def AddCalleeAuthid(builder, calleeAuthid):
+    return YieldAddCalleeAuthid(builder, calleeAuthid)
+def YieldAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
+def AddCalleeAuthrole(builder, calleeAuthrole):
+    return YieldAddCalleeAuthrole(builder, calleeAuthrole)
+def YieldAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return YieldAddForwardFor(builder, forwardFor)
+def YieldStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return YieldStartForwardForVector(builder, numElems)
+def YieldEnd(builder): return builder.EndObject()
+def End(builder):
+    return YieldEnd(builder)