cent 3.0.0 → 5.0.0

data/lib/cent/generated/proxy_types.rb

@@ -0,0 +1,1834 @@
+# frozen_string_literal: true
+
+# Code generated by gen/generate.rb from proto/proxy.proto. DO NOT EDIT.
+
+module Cent
+  module Proxy
+    # FilterNode is a node of a publication tags filter expression. A leaf node
+    # compares one tag: it sets key, cmp and val or vals, and leaves op empty. A
+    # logical node combines its nodes: it sets op and nodes only.
+    #
+    # @!attribute [r] op
+    #   @return [String] The logical operation. Empty for a leaf node. One of: and, or, not.
+    # @!attribute [r] key
+    #   @return [String] The tag a leaf node compares.
+    # @!attribute [r] cmp
+    #   @return [String] The comparison of a leaf node: ex is exists, nex does not exist,
+    #     sw starts with, ew ends with, ct contains. One of: eq, neq, in, nin, ex,
+    #     nex, sw, ew, ct, gt, gte, lt, lte.
+    # @!attribute [r] val
+    #   @return [String] The value most comparisons compare the tag with.
+    # @!attribute [r] vals
+    #   @return [Array<String>] The values "in" and "nin" compare the tag with.
+    # @!attribute [r] nodes
+    #   @return [Array<FilterNode>] The operands of a logical node.
+    class FilterNode < Data.define(:op, :key, :cmp, :val, :vals, :nodes)
+      include Message
+
+      def initialize(
+        op: "",
+        key: "",
+        cmp: "",
+        val: "",
+        vals: [],
+        nodes: []
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "op", op, where, :str)
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "cmp", cmp, where, :str)
+        Wire.put(w, "val", val, where, :str)
+        Wire.put(w, "vals", vals, where, :str, :list)
+        Wire.put(w, "nodes", nodes, where, FilterNode, :list)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "FilterNode")
+        d = Wire.obj(v, where)
+        new(
+          op: Wire.get(d, "op", where, :str),
+          key: Wire.get(d, "key", where, :str),
+          cmp: Wire.get(d, "cmp", where, :str),
+          val: Wire.get(d, "val", where, :str),
+          vals: Wire.get(d, "vals", where, :str, :list),
+          nodes: Wire.get(d, "nodes", where, FilterNode, :list)
+        )
+      end
+    end
+
+    # ConnectRequest is sent when a client connects.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport: "websocket", "sse", "uni_sse" and
+    #     the like.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] data
+    #   @return [Object, nil] The custom data the client sent with its connect command, if any.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, sent instead of data in binary encoding mode.
+    # @!attribute [r] name
+    #   @return [String] The client's name, if it sent one.
+    # @!attribute [r] version
+    #   @return [String] The client's version, if it sent one.
+    # @!attribute [r] channels
+    #   @return [Array<String>] The server-side channels the client asks to be subscribed
+    #     to. The backend checks its permissions and returns the allowed ones in
+    #     ConnectResult.channels or ConnectResult.subs.
+    class ConnectRequest < Data.define(:client, :transport, :protocol, :encoding, :data, :b64data, :name, :version, :channels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        data: nil,
+        b64data: "",
+        name: "",
+        version: "",
+        channels: []
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "name", name, where, :str)
+        Wire.put(w, "version", version, where, :str)
+        Wire.put(w, "channels", channels, where, :str, :list)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "ConnectRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          name: Wire.get(d, "name", where, :str),
+          version: Wire.get(d, "version", where, :str),
+          channels: Wire.get(d, "channels", where, :str, :list)
+        )
+      end
+    end
+
+    # SubscribeOptions are the options of a server-side subscription returned in
+    # ConnectResult.subs.
+    #
+    # @!attribute [r] expire_at
+    #   @return [Integer] When the subscription expires, in Unix seconds. Zero means it
+    #     does not expire.
+    # @!attribute [r] info
+    #   @return [Object, nil] Channel-specific information about the connection, as JSON: it is
+    #     part of presence data, join and leave events and the client's
+    #     publications in the channel.
+    # @!attribute [r] b64info
+    #   @return [String] Info in base64, for binary info.
+    # @!attribute [r] data
+    #   @return [Object, nil] Custom data sent to the client with the subscription in the
+    #     connect reply.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    # @!attribute [r] override
+    #   @return [SubscribeOptionOverride, nil] Overrides channel options of the namespace for this
+    #     subscription.
+    # @!attribute [r] server_tags_filter
+    #   @return [FilterNode, nil] Makes the subscription receive only publications
+    #     whose tags match it. Centrifugo PRO only.
+    # @!attribute [r] cache_recover
+    #   @return [Boolean] When set, makes Centrifugo initiate cache recovery for the
+    #     server-side subscription without requiring the client to provide a recover
+    #     flag/position itself. This is the server-side equivalent of subscribing with an
+    #     empty `since` on the client. Mostly useful for unidirectional clients which do
+    #     not know channel names. Requires recovery to be enabled for the channel and only
+    #     applies in cache recovery mode, where it delivers the latest publication on
+    #     (re)subscribe.
+    class SubscribeOptions < Data.define(:expire_at, :info, :b64info, :data, :b64data, :override, :server_tags_filter, :cache_recover)
+      include Message
+
+      def initialize(
+        expire_at: 0,
+        info: nil,
+        b64info: "",
+        data: nil,
+        b64data: "",
+        override: nil,
+        server_tags_filter: nil,
+        cache_recover: false
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "expire_at", expire_at, where, :int)
+        Wire.put(w, "info", info, where, :json)
+        Wire.put(w, "b64info", b64info, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "override", override, where, SubscribeOptionOverride)
+        Wire.put(w, "server_tags_filter", server_tags_filter, where, FilterNode)
+        Wire.put(w, "cache_recover", cache_recover, where, :bool)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubscribeOptions")
+        d = Wire.obj(v, where)
+        new(
+          expire_at: Wire.get(d, "expire_at", where, :int),
+          info: Wire.get(d, "info", where, :json),
+          b64info: Wire.get(d, "b64info", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          override: Wire.get(d, "override", where, SubscribeOptionOverride),
+          server_tags_filter: Wire.get(d, "server_tags_filter", where, FilterNode),
+          cache_recover: Wire.get(d, "cache_recover", where, :bool)
+        )
+      end
+    end
+
+    # ConnectResult accepts the connection.
+    #
+    # @!attribute [r] user
+    #   @return [String] The ID of the user the connection belongs to. Empty accepts an
+    #     anonymous connection.
+    # @!attribute [r] expire_at
+    #   @return [Integer] When the connection expires, in Unix seconds, unless
+    #     refreshed - by the refresh proxy, when one is configured. Zero means it
+    #     does not expire.
+    # @!attribute [r] info
+    #   @return [Object, nil] Information about the connection, as JSON: it is part of presence
+    #     data, join and leave events and the client's publications.
+    # @!attribute [r] b64info
+    #   @return [String] Info in base64, for binary info.
+    # @!attribute [r] data
+    #   @return [Object, nil] Custom data sent to the client in the connect reply.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    # @!attribute [r] channels
+    #   @return [Array<String>] Server-side channels to subscribe the connection to.
+    # @!attribute [r] subs
+    #   @return [Hash{String => SubscribeOptions}] Server-side channels to subscribe the connection to, each with
+    #     its options.
+    # @!attribute [r] meta
+    #   @return [Object, nil] Custom data attached to the connection, as JSON. It is never sent
+    #     to the client; proxies with include_connection_meta receive it.
+    # @!attribute [r] caps
+    #   @return [Array<ChannelsCapability>] Capabilities granting the connection operations in channels.
+    #     Centrifugo PRO only.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — client labels attached to the centrifuge.Client by Centrifugo PRO.
+    #     Parsed by OSS but not used (OSS does not populate centrifuge.ConnectReply.Labels).
+    # @!attribute [r] profile
+    #   @return [String] Assigns the connection to a dictionary compression profile, as the
+    #     profile claim of a connection token does: it overrides the profile the
+    #     client declared. Centrifugo PRO only.
+    class ConnectResult < Data.define(:user, :expire_at, :info, :b64info, :data, :b64data, :channels, :subs, :meta, :caps, :labels, :profile)
+      include Message
+
+      def initialize(
+        user: "",
+        expire_at: 0,
+        info: nil,
+        b64info: "",
+        data: nil,
+        b64data: "",
+        channels: [],
+        subs: {},
+        meta: nil,
+        caps: [],
+        labels: {},
+        profile: ""
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "expire_at", expire_at, where, :int)
+        Wire.put(w, "info", info, where, :json)
+        Wire.put(w, "b64info", b64info, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "channels", channels, where, :str, :list)
+        Wire.put(w, "subs", subs, where, SubscribeOptions, :map)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "caps", caps, where, ChannelsCapability, :list)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        Wire.put(w, "profile", profile, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "ConnectResult")
+        d = Wire.obj(v, where)
+        new(
+          user: Wire.get(d, "user", where, :str),
+          expire_at: Wire.get(d, "expire_at", where, :int),
+          info: Wire.get(d, "info", where, :json),
+          b64info: Wire.get(d, "b64info", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          channels: Wire.get(d, "channels", where, :str, :list),
+          subs: Wire.get(d, "subs", where, SubscribeOptions, :map),
+          meta: Wire.get(d, "meta", where, :json),
+          caps: Wire.get(d, "caps", where, ChannelsCapability, :list),
+          labels: Wire.get(d, "labels", where, :str, :map),
+          profile: Wire.get(d, "profile", where, :str)
+        )
+      end
+    end
+
+    # ChannelsCapability grants operations in channels. A connection may do an
+    # operation in a channel when any of its capabilities both allows the
+    # operation and matches the channel. Centrifugo PRO only.
+    #
+    # @!attribute [r] channels
+    #   @return [Array<String>] The channels, or channel patterns, it applies to.
+    # @!attribute [r] allow
+    #   @return [Array<String>] The operations it grants: sub is subscribe, pub publish, hst
+    #     history, prs presence. One of: sub, pub, hst, prs.
+    # @!attribute [r] match
+    #   @return [String] How channels are matched: empty for exact names. One of:
+    #     wildcard, regex.
+    class ChannelsCapability < Data.define(:channels, :allow, :match)
+      include Message
+
+      def initialize(channels: [], allow: [], match: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "channels", channels, where, :str, :list)
+        Wire.put(w, "allow", allow, where, :str, :list)
+        Wire.put(w, "match", match, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "ChannelsCapability")
+        d = Wire.obj(v, where)
+        new(
+          channels: Wire.get(d, "channels", where, :str, :list),
+          allow: Wire.get(d, "allow", where, :str, :list),
+          match: Wire.get(d, "match", where, :str)
+        )
+      end
+    end
+
+    # RefreshRequest is sent when a connection is about to expire.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class RefreshRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "RefreshRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # RefreshResult extends the connection, or ends it.
+    #
+    # @!attribute [r] expired
+    #   @return [Boolean] Disconnects the client: its connection has expired.
+    # @!attribute [r] expire_at
+    #   @return [Integer] When the connection expires next, in Unix seconds.
+    # @!attribute [r] info
+    #   @return [Object, nil] Replaces the connection's info, as JSON.
+    # @!attribute [r] b64info
+    #   @return [String] Info in base64, for binary info.
+    # @!attribute [r] meta
+    #   @return [Object, nil] Replaces the connection's meta, as JSON.
+    # @!attribute [r] caps
+    #   @return [Array<ChannelsCapability>] Replace the connection's capabilities. Centrifugo PRO only.
+    class RefreshResult < Data.define(:expired, :expire_at, :info, :b64info, :meta, :caps)
+      include Message
+
+      def initialize(
+        expired: false,
+        expire_at: 0,
+        info: nil,
+        b64info: "",
+        meta: nil,
+        caps: []
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "expired", expired, where, :bool)
+        Wire.put(w, "expire_at", expire_at, where, :int)
+        Wire.put(w, "info", info, where, :json)
+        Wire.put(w, "b64info", b64info, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "caps", caps, where, ChannelsCapability, :list)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "RefreshResult")
+        d = Wire.obj(v, where)
+        new(
+          expired: Wire.get(d, "expired", where, :bool),
+          expire_at: Wire.get(d, "expire_at", where, :int),
+          info: Wire.get(d, "info", where, :json),
+          b64info: Wire.get(d, "b64info", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          caps: Wire.get(d, "caps", where, ChannelsCapability, :list)
+        )
+      end
+    end
+
+    # SubscribeRequest is sent when a client subscribes to a channel.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] channel
+    #   @return [String] The channel the client subscribes to.
+    # @!attribute [r] token
+    #   @return [String] The subscription token the client sent for the channel, if any.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] data
+    #   @return [Object, nil] The custom data the client sent with its subscribe command, if any.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, sent instead of data in binary encoding mode.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class SubscribeRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :channel, :token, :meta, :data, :b64data, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        channel: "",
+        token: "",
+        meta: nil,
+        data: nil,
+        b64data: "",
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "token", token, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubscribeRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          channel: Wire.get(d, "channel", where, :str),
+          token: Wire.get(d, "token", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # SubscribeOptionOverride overrides channel options of the namespace for one
+    # subscription. An unset field keeps the namespace's value.
+    #
+    # @!attribute [r] presence
+    #   @return [Boolean, nil] Overrides the namespace's presence option.
+    # @!attribute [r] join_leave
+    #   @return [Boolean, nil] Overrides the namespace's join_leave option.
+    # @!attribute [r] force_recovery
+    #   @return [Boolean, nil] Overrides the namespace's force_recovery option.
+    # @!attribute [r] force_positioning
+    #   @return [Boolean, nil] Overrides the namespace's force_positioning option.
+    # @!attribute [r] force_push_join_leave
+    #   @return [Boolean, nil] Overrides the namespace's force_push_join_leave
+    #     option.
+    class SubscribeOptionOverride < Data.define(:presence, :join_leave, :force_recovery, :force_positioning, :force_push_join_leave)
+      include Message
+
+      def initialize(
+        presence: nil,
+        join_leave: nil,
+        force_recovery: nil,
+        force_positioning: nil,
+        force_push_join_leave: nil
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "presence", presence, where, :bool_value)
+        Wire.put(w, "join_leave", join_leave, where, :bool_value)
+        Wire.put(w, "force_recovery", force_recovery, where, :bool_value)
+        Wire.put(w, "force_positioning", force_positioning, where, :bool_value)
+        Wire.put(w, "force_push_join_leave", force_push_join_leave, where, :bool_value)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubscribeOptionOverride")
+        d = Wire.obj(v, where)
+        new(
+          presence: Wire.get(d, "presence", where, :bool_value),
+          join_leave: Wire.get(d, "join_leave", where, :bool_value),
+          force_recovery: Wire.get(d, "force_recovery", where, :bool_value),
+          force_positioning: Wire.get(d, "force_positioning", where, :bool_value),
+          force_push_join_leave: Wire.get(d, "force_push_join_leave", where, :bool_value)
+        )
+      end
+    end
+
+    # SubscribeResult accepts the subscription.
+    #
+    # @!attribute [r] expire_at
+    #   @return [Integer] When the subscription expires, in Unix seconds, unless
+    #     refreshed - by the sub refresh proxy, when one is configured. Zero means
+    #     it does not expire.
+    # @!attribute [r] info
+    #   @return [Object, nil] Channel-specific information about the connection, as JSON: it is
+    #     part of presence data, join and leave events and the client's
+    #     publications in the channel.
+    # @!attribute [r] b64info
+    #   @return [String] Info in base64, for binary info.
+    # @!attribute [r] data
+    #   @return [Object, nil] Custom data sent to the client in the subscribe reply.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    # @!attribute [r] override
+    #   @return [SubscribeOptionOverride, nil] Overrides channel options of the namespace for this
+    #     subscription.
+    # @!attribute [r] allow
+    #   @return [Array<String>] Capabilities granted in the channel for this subscription.
+    #     Centrifugo PRO only. One of: sub, pub, hst, prs.
+    # @!attribute [r] server_tags_filter
+    #   @return [FilterNode, nil] Makes the subscription receive only publications
+    #     whose tags match it. Centrifugo PRO only.
+    class SubscribeResult < Data.define(:expire_at, :info, :b64info, :data, :b64data, :override, :allow, :server_tags_filter)
+      include Message
+
+      def initialize(
+        expire_at: 0,
+        info: nil,
+        b64info: "",
+        data: nil,
+        b64data: "",
+        override: nil,
+        allow: [],
+        server_tags_filter: nil
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "expire_at", expire_at, where, :int)
+        Wire.put(w, "info", info, where, :json)
+        Wire.put(w, "b64info", b64info, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "override", override, where, SubscribeOptionOverride)
+        Wire.put(w, "allow", allow, where, :str, :list)
+        Wire.put(w, "server_tags_filter", server_tags_filter, where, FilterNode)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubscribeResult")
+        d = Wire.obj(v, where)
+        new(
+          expire_at: Wire.get(d, "expire_at", where, :int),
+          info: Wire.get(d, "info", where, :json),
+          b64info: Wire.get(d, "b64info", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          override: Wire.get(d, "override", where, SubscribeOptionOverride),
+          allow: Wire.get(d, "allow", where, :str, :list),
+          server_tags_filter: Wire.get(d, "server_tags_filter", where, FilterNode)
+        )
+      end
+    end
+
+    # PublishRequest is sent when a client publishes into a channel.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] channel
+    #   @return [String] The channel the client publishes into.
+    # @!attribute [r] data
+    #   @return [Object, nil] The data the client publishes.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, sent instead of data in binary encoding mode.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class PublishRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :channel, :data, :b64data, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        channel: "",
+        data: nil,
+        b64data: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "PublishRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          channel: Wire.get(d, "channel", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # PublishResult accepts the publication. Fields left unset keep what the
+    # client sent, or the defaults.
+    #
+    # @!attribute [r] data
+    #   @return [Object, nil] Replaces the data the client sent.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    # @!attribute [r] skip_history
+    #   @return [Boolean] Publishes without saving the publication to the channel's
+    #     history. Not allowed in channels with delta compression.
+    # @!attribute [r] tags
+    #   @return [Hash{String => String}] Attached to the publication: clients cannot send tags, so this
+    #     is where server-side tag filters get their tags from.
+    # @!attribute [r] idempotency_key
+    #   @return [String] Makes the publication idempotent: another one with the
+    #     same key in the channel within the broker's idempotency window is not
+    #     published.
+    # @!attribute [r] delta
+    #   @return [Boolean] Enables delta compression for the publication.
+    # @!attribute [r] version
+    #   @return [Integer] The publication's version, for channels whose publications
+    #     each carry the whole state: Centrifugo drops one older than the latest.
+    # @!attribute [r] version_epoch
+    #   @return [String] Scopes version, for versions which may start over - when
+    #     they come from a system which can lose its state, say.
+    class PublishResult < Data.define(:data, :b64data, :skip_history, :tags, :idempotency_key, :delta, :version, :version_epoch)
+      include Message
+
+      def initialize(
+        data: nil,
+        b64data: "",
+        skip_history: false,
+        tags: {},
+        idempotency_key: "",
+        delta: false,
+        version: 0,
+        version_epoch: ""
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "skip_history", skip_history, where, :bool)
+        Wire.put(w, "tags", tags, where, :str, :map)
+        Wire.put(w, "idempotency_key", idempotency_key, where, :str)
+        Wire.put(w, "delta", delta, where, :bool)
+        Wire.put(w, "version", version, where, :int)
+        Wire.put(w, "version_epoch", version_epoch, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "PublishResult")
+        d = Wire.obj(v, where)
+        new(
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          skip_history: Wire.get(d, "skip_history", where, :bool),
+          tags: Wire.get(d, "tags", where, :str, :map),
+          idempotency_key: Wire.get(d, "idempotency_key", where, :str),
+          delta: Wire.get(d, "delta", where, :bool),
+          version: Wire.get(d, "version", where, :int),
+          version_epoch: Wire.get(d, "version_epoch", where, :str)
+        )
+      end
+    end
+
+    # MapPublishRequest is sent when a client publishes a key into a map channel.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] channel
+    #   @return [String] The map channel the client publishes into.
+    # @!attribute [r] key
+    #   @return [String] The key the client publishes, empty if it sent none.
+    # @!attribute [r] data
+    #   @return [Object, nil] The data the client publishes.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, sent instead of data in binary encoding mode.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class MapPublishRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :channel, :key, :data, :b64data, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        channel: "",
+        key: "",
+        data: nil,
+        b64data: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "MapPublishRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          channel: Wire.get(d, "channel", where, :str),
+          key: Wire.get(d, "key", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # MapPublishResult accepts the publication, even when empty. Fields left
+    # unset keep what the client sent, or the defaults.
+    #
+    # @!attribute [r] key
+    #   @return [String] Replaces the key the client sent: to force a key the server derives,
+    #     such as the user ID.
+    # @!attribute [r] data
+    #   @return [Object, nil] Replaces the data the client sent.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    # @!attribute [r] tags
+    #   @return [Hash{String => String}] Attached to the publication: clients cannot send tags, so this
+    #     is where server-side tag filters get their tags from.
+    # @!attribute [r] score
+    #   @return [Integer] Not used by Centrifugo yet.
+    # @!attribute [r] key_mode
+    #   @return [String] Makes the publication conditional: if_new publishes only a key
+    #     which does not exist yet, if_exists only one which does.
+    #     One of: if_new, if_exists.
+    # @!attribute [r] stream_data
+    #   @return [Object, nil] Not used by Centrifugo yet.
+    # @!attribute [r] b64stream_data
+    #   @return [String] Not used by Centrifugo yet.
+    # @!attribute [r] idempotency_key
+    #   @return [String] Makes the publication idempotent: another one with the
+    #     same key within the broker's idempotency window is not published.
+    # @!attribute [r] delta
+    #   @return [Boolean] Enables delta compression for the publication.
+    # @!attribute [r] version
+    #   @return [Integer] The key's version: Centrifugo drops a publication older than
+    #     the key's latest.
+    # @!attribute [r] version_epoch
+    #   @return [String] Scopes version, for versions which may start over.
+    class MapPublishResult < Data.define(:key, :data, :b64data, :tags, :score, :key_mode, :stream_data, :b64stream_data, :idempotency_key, :delta, :version, :version_epoch)
+      include Message
+
+      def initialize(
+        key: "",
+        data: nil,
+        b64data: "",
+        tags: {},
+        score: 0,
+        key_mode: "",
+        stream_data: nil,
+        b64stream_data: "",
+        idempotency_key: "",
+        delta: false,
+        version: 0,
+        version_epoch: ""
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "tags", tags, where, :str, :map)
+        Wire.put(w, "score", score, where, :int)
+        Wire.put(w, "key_mode", key_mode, where, :str)
+        Wire.put(w, "stream_data", stream_data, where, :json)
+        Wire.put(w, "b64stream_data", b64stream_data, where, :str)
+        Wire.put(w, "idempotency_key", idempotency_key, where, :str)
+        Wire.put(w, "delta", delta, where, :bool)
+        Wire.put(w, "version", version, where, :int)
+        Wire.put(w, "version_epoch", version_epoch, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "MapPublishResult")
+        d = Wire.obj(v, where)
+        new(
+          key: Wire.get(d, "key", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          tags: Wire.get(d, "tags", where, :str, :map),
+          score: Wire.get(d, "score", where, :int),
+          key_mode: Wire.get(d, "key_mode", where, :str),
+          stream_data: Wire.get(d, "stream_data", where, :json),
+          b64stream_data: Wire.get(d, "b64stream_data", where, :str),
+          idempotency_key: Wire.get(d, "idempotency_key", where, :str),
+          delta: Wire.get(d, "delta", where, :bool),
+          version: Wire.get(d, "version", where, :int),
+          version_epoch: Wire.get(d, "version_epoch", where, :str)
+        )
+      end
+    end
+
+    # MapRemoveRequest is sent when a client removes a key from a map channel.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] channel
+    #   @return [String] The map channel the client removes the key from.
+    # @!attribute [r] key
+    #   @return [String] The key the client removes.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class MapRemoveRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :channel, :key, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        channel: "",
+        key: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "MapRemoveRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          channel: Wire.get(d, "channel", where, :str),
+          key: Wire.get(d, "key", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # MapRemoveResult accepts the removal, even when empty. Fields left unset
+    # keep what the client sent, or the defaults.
+    #
+    # @!attribute [r] key
+    #   @return [String] Replaces the key the client sent.
+    # @!attribute [r] tags
+    #   @return [Hash{String => String}] Attached to the removal publication. When unset, the removed
+    #     entry's own tags are.
+    # @!attribute [r] idempotency_key
+    #   @return [String] Makes the removal idempotent within the broker's
+    #     idempotency window.
+    class MapRemoveResult < Data.define(:key, :tags, :idempotency_key)
+      include Message
+
+      def initialize(key: "", tags: {}, idempotency_key: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "tags", tags, where, :str, :map)
+        Wire.put(w, "idempotency_key", idempotency_key, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "MapRemoveResult")
+        d = Wire.obj(v, where)
+        new(
+          key: Wire.get(d, "key", where, :str),
+          tags: Wire.get(d, "tags", where, :str, :map),
+          idempotency_key: Wire.get(d, "idempotency_key", where, :str)
+        )
+      end
+    end
+
+    # RPCRequest is sent when a client makes an RPC call.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] method
+    #   @return [String] The method the client calls, empty if it named none.
+    # @!attribute [r] data
+    #   @return [Object, nil] The data the client sent with the call.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, sent instead of data in binary encoding mode.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class RPCRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :method, :data, :b64data, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        method: "",
+        data: nil,
+        b64data: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "method", method, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "RPCRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          method: Wire.get(d, "method", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # RPCResult is the call's result.
+    #
+    # @!attribute [r] data
+    #   @return [Object, nil] The result sent to the client: any JSON.
+    # @!attribute [r] b64data
+    #   @return [String] Data in base64, for binary data.
+    class RPCResult < Data.define(:data, :b64data)
+      include Message
+
+      def initialize(data: nil, b64data: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "b64data", b64data, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "RPCResult")
+        d = Wire.obj(v, where)
+        new(
+          data: Wire.get(d, "data", where, :json),
+          b64data: Wire.get(d, "b64data", where, :str)
+        )
+      end
+    end
+
+    # SubRefreshRequest is sent when a subscription is about to expire.
+    #
+    # @!attribute [r] client
+    #   @return [String] The unique ID Centrifugo gave the connection.
+    # @!attribute [r] transport
+    #   @return [String] The connection's transport.
+    # @!attribute [r] protocol
+    #   @return [String] The client protocol. One of: json, protobuf.
+    # @!attribute [r] encoding
+    #   @return [String] Binary when the proxy has binary_encoding enabled, so that
+    #     payloads come in the b64 fields, and json otherwise.
+    #     One of: json, binary.
+    # @!attribute [r] user
+    #   @return [String] The connection's user ID.
+    # @!attribute [r] channel
+    #   @return [String] The channel whose subscription is about to expire.
+    # @!attribute [r] meta
+    #   @return [Object, nil] The connection's meta, when the proxy has include_connection_meta.
+    # @!attribute [r] labels
+    #   @return [Hash{String => String}] PRO only — connection labels attached to the originating centrifuge.Client.
+    #     Centrifugo PRO always populates this from Client.Labels() (no opt-in toggle).
+    class SubRefreshRequest < Data.define(:client, :transport, :protocol, :encoding, :user, :channel, :meta, :labels)
+      include Message
+
+      def initialize(
+        client: "",
+        transport: "",
+        protocol: "",
+        encoding: "",
+        user: "",
+        channel: "",
+        meta: nil,
+        labels: {}
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "client", client, where, :str)
+        Wire.put(w, "transport", transport, where, :str)
+        Wire.put(w, "protocol", protocol, where, :str)
+        Wire.put(w, "encoding", encoding, where, :str)
+        Wire.put(w, "user", user, where, :str)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "meta", meta, where, :json)
+        Wire.put(w, "labels", labels, where, :str, :map)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubRefreshRequest")
+        d = Wire.obj(v, where)
+        new(
+          client: Wire.get(d, "client", where, :str),
+          transport: Wire.get(d, "transport", where, :str),
+          protocol: Wire.get(d, "protocol", where, :str),
+          encoding: Wire.get(d, "encoding", where, :str),
+          user: Wire.get(d, "user", where, :str),
+          channel: Wire.get(d, "channel", where, :str),
+          meta: Wire.get(d, "meta", where, :json),
+          labels: Wire.get(d, "labels", where, :str, :map)
+        )
+      end
+    end
+
+    # SubRefreshResult extends the subscription, or ends it.
+    #
+    # @!attribute [r] expired
+    #   @return [Boolean] Ends the subscription: it has expired.
+    # @!attribute [r] expire_at
+    #   @return [Integer] When the subscription expires next, in Unix seconds.
+    # @!attribute [r] info
+    #   @return [Object, nil] Replaces the channel-specific information about the connection, as
+    #     JSON.
+    # @!attribute [r] b64info
+    #   @return [String] Info in base64, for binary info.
+    # @!attribute [r] server_tags_filter
+    #   @return [FilterNode, nil] When set, replaces the server-side tags filter of the
+    #     subscription (Centrifugo PRO). When not set the filter is kept as it is.
+    class SubRefreshResult < Data.define(:expired, :expire_at, :info, :b64info, :server_tags_filter)
+      include Message
+
+      def initialize(
+        expired: false,
+        expire_at: 0,
+        info: nil,
+        b64info: "",
+        server_tags_filter: nil
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "expired", expired, where, :bool)
+        Wire.put(w, "expire_at", expire_at, where, :int)
+        Wire.put(w, "info", info, where, :json)
+        Wire.put(w, "b64info", b64info, where, :str)
+        Wire.put(w, "server_tags_filter", server_tags_filter, where, FilterNode)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SubRefreshResult")
+        d = Wire.obj(v, where)
+        new(
+          expired: Wire.get(d, "expired", where, :bool),
+          expire_at: Wire.get(d, "expire_at", where, :int),
+          info: Wire.get(d, "info", where, :json),
+          b64info: Wire.get(d, "b64info", where, :str),
+          server_tags_filter: Wire.get(d, "server_tags_filter", where, FilterNode)
+        )
+      end
+    end
+
+    # NotifyCacheEmptyRequest is sent when a client subscribed to a channel in
+    # cache recovery mode which has no publication to recover from. Centrifugo
+    # PRO only.
+    #
+    # @!attribute [r] channel
+    #   @return [String] The channel whose cache is empty.
+    class NotifyCacheEmptyRequest < Data.define(:channel)
+      include Message
+
+      def initialize(channel: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "channel", channel, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "NotifyCacheEmptyRequest")
+        d = Wire.obj(v, where)
+        new(
+          channel: Wire.get(d, "channel", where, :str)
+        )
+      end
+    end
+
+    # NotifyCacheEmptyResult is the NotifyCacheEmptyResult message of the Centrifugo proxy protocol.
+    #
+    # @!attribute [r] populated
+    #   @return [Boolean] Tells Centrifugo that the backend published into the channel,
+    #     so that it tries to recover the state once more.
+    class NotifyCacheEmptyResult < Data.define(:populated)
+      include Message
+
+      def initialize(populated: false) = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "populated", populated, where, :bool)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "NotifyCacheEmptyResult")
+        d = Wire.obj(v, where)
+        new(
+          populated: Wire.get(d, "populated", where, :bool)
+        )
+      end
+    end
+
+    # NotifyChannelStateRequest carries channel state events. Centrifugo PRO
+    # only, in preview.
+    #
+    # @!attribute [r] events
+    #   @return [Array<ChannelEvent>] The events which happened, in channels with presence.
+    class NotifyChannelStateRequest < Data.define(:events)
+      include Message
+
+      def initialize(events: []) = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "events", events, where, ChannelEvent, :list)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "NotifyChannelStateRequest")
+        d = Wire.obj(v, where)
+        new(
+          events: Wire.get(d, "events", where, ChannelEvent, :list)
+        )
+      end
+    end
+
+    # ChannelEvent is a change of a channel's state.
+    #
+    # @!attribute [r] time_ms
+    #   @return [Integer] When it happened, in Unix milliseconds.
+    # @!attribute [r] channel
+    #   @return [String] The channel it happened in.
+    # @!attribute [r] type
+    #   @return [String] Occupied when the channel got its first subscriber, vacated
+    #     when it lost its last one. More types may come; the field is a string,
+    #     not an enum, for JSON interoperability. One of: occupied, vacated.
+    class ChannelEvent < Data.define(:time_ms, :channel, :type)
+      include Message
+
+      def initialize(time_ms: 0, channel: "", type: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "time_ms", time_ms, where, :int)
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "type", type, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "ChannelEvent")
+        d = Wire.obj(v, where)
+        new(
+          time_ms: Wire.get(d, "time_ms", where, :int),
+          channel: Wire.get(d, "channel", where, :str),
+          type: Wire.get(d, "type", where, :str)
+        )
+      end
+    end
+
+    # NotifyChannelStateResult is the NotifyChannelStateResult message of the Centrifugo proxy protocol.
+    class NotifyChannelStateResult < Data.define
+      include Message
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(_where = "")
+        {}
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "NotifyChannelStateResult")
+        Wire.obj(v, where)
+        new
+      end
+    end
+
+    # SharedPollRefreshRequest asks for the current data of items tracked in a
+    # shared poll channel.
+    #
+    # @!attribute [r] channel
+    #   @return [String] The shared poll channel.
+    # @!attribute [r] items
+    #   @return [Array<SharedPollRefreshItem>] The tracked items to refresh.
+    class SharedPollRefreshRequest < Data.define(:channel, :items)
+      include Message
+
+      def initialize(channel: "", items: []) = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "channel", channel, where, :str)
+        Wire.put(w, "items", items, where, SharedPollRefreshItem, :list)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SharedPollRefreshRequest")
+        d = Wire.obj(v, where)
+        new(
+          channel: Wire.get(d, "channel", where, :str),
+          items: Wire.get(d, "items", where, SharedPollRefreshItem, :list)
+        )
+      end
+    end
+
+    # SharedPollRefreshItem is an item to refresh.
+    #
+    # @!attribute [r] key
+    #   @return [String] The item's key.
+    # @!attribute [r] version
+    #   @return [Integer] The latest version of the item Centrifugo has, in versioned
+    #     mode: zero when it has none. Not set in versionless mode.
+    class SharedPollRefreshItem < Data.define(:key, :version)
+      include Message
+
+      def initialize(key: "", version: 0) = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "version", version, where, :int)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SharedPollRefreshItem")
+        d = Wire.obj(v, where)
+        new(
+          key: Wire.get(d, "key", where, :str),
+          version: Wire.get(d, "version", where, :int)
+        )
+      end
+    end
+
+    # SharedPollRefreshResult carries the items' current data. An item left out
+    # is unchanged.
+    #
+    # @!attribute [r] items
+    #   @return [Array<SharedPollRefreshResultItem>] The items' current data.
+    # @!attribute [r] epoch
+    #   @return [String] Identifies the publisher's version space: when it differs from
+    #     the channel's, Centrifugo drops the versions and data it keeps and
+    #     resubscribes the channel's subscribers. Generate one per process start, and
+    #     send the same one with direct publishes. Empty means versions are never
+    #     reset.
+    class SharedPollRefreshResult < Data.define(:items, :epoch)
+      include Message
+
+      def initialize(items: [], epoch: "") = super
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "items", items, where, SharedPollRefreshResultItem, :list)
+        Wire.put(w, "epoch", epoch, where, :str)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SharedPollRefreshResult")
+        d = Wire.obj(v, where)
+        new(
+          items: Wire.get(d, "items", where, SharedPollRefreshResultItem, :list),
+          epoch: Wire.get(d, "epoch", where, :str)
+        )
+      end
+    end
+
+    # SharedPollRefreshResultItem is an item's current data.
+    #
+    # @!attribute [r] key
+    #   @return [String] The item's key.
+    # @!attribute [r] data
+    #   @return [Object, nil] The item's data. In versioned mode it may be left out for an
+    #     item which has not changed.
+    # @!attribute [r] version
+    #   @return [Integer] The item's version: required in versioned mode, optional in
+    #     versionless mode. It must grow when the item changes.
+    # @!attribute [r] removed
+    #   @return [Boolean] Removes the item: subscribers are told so, and it is no longer
+    #     tracked.
+    # @!attribute [r] prev_data
+    #   @return [Object, nil] The item's previous data, the base for delta compression
+    #     when the namespace uses it, so that Centrifugo need not keep it.
+    class SharedPollRefreshResultItem < Data.define(:key, :data, :version, :removed, :prev_data)
+      include Message
+
+      def initialize(
+        key: "",
+        data: nil,
+        version: 0,
+        removed: false,
+        prev_data: nil
+      )
+        super
+      end
+
+      # The message as Centrifugo reads it, fields at their zero value left out.
+      #
+      # @api private
+      def to_wire(where = "")
+        w = {}
+        Wire.put(w, "key", key, where, :str)
+        Wire.put(w, "data", data, where, :json)
+        Wire.put(w, "version", version, where, :int)
+        Wire.put(w, "removed", removed, where, :bool)
+        Wire.put(w, "prev_data", prev_data, where, :json)
+        w
+      end
+
+      # The message from the Hash JSON.parse gives for it.
+      #
+      # @api private
+      def self.from_wire(v, where = "SharedPollRefreshResultItem")
+        d = Wire.obj(v, where)
+        new(
+          key: Wire.get(d, "key", where, :str),
+          data: Wire.get(d, "data", where, :json),
+          version: Wire.get(d, "version", where, :int),
+          removed: Wire.get(d, "removed", where, :bool),
+          prev_data: Wire.get(d, "prev_data", where, :json)
+        )
+      end
+    end
+
+    # The values of FilterNode.op. The field is a String: a value Centrifugo sends
+    # or accepts which these do not name is still a valid one.
+
+    # The FilterNodeOp "and".
+    FILTER_NODE_OP_AND = "and"
+
+    # The FilterNodeOp "or".
+    FILTER_NODE_OP_OR = "or"
+
+    # The FilterNodeOp "not".
+    FILTER_NODE_OP_NOT = "not"
+
+    # The values of FilterNode.cmp. The field is a String: a value Centrifugo
+    # sends or accepts which these do not name is still a valid one.
+
+    # The Cmp "eq".
+    CMP_EQ = "eq"
+
+    # The Cmp "neq".
+    CMP_NEQ = "neq"
+
+    # The Cmp "in".
+    CMP_IN = "in"
+
+    # The Cmp "nin".
+    CMP_NIN = "nin"
+
+    # The Cmp "ex".
+    CMP_EX = "ex"
+
+    # The Cmp "nex".
+    CMP_NEX = "nex"
+
+    # The Cmp "sw".
+    CMP_SW = "sw"
+
+    # The Cmp "ew".
+    CMP_EW = "ew"
+
+    # The Cmp "ct".
+    CMP_CT = "ct"
+
+    # The Cmp "gt".
+    CMP_GT = "gt"
+
+    # The Cmp "gte".
+    CMP_GTE = "gte"
+
+    # The Cmp "lt".
+    CMP_LT = "lt"
+
+    # The Cmp "lte".
+    CMP_LTE = "lte"
+
+    # The values of ConnectRequest.protocol, RefreshRequest.protocol,
+    # SubscribeRequest.protocol, PublishRequest.protocol,
+    # MapPublishRequest.protocol, MapRemoveRequest.protocol, RPCRequest.protocol
+    # and SubRefreshRequest.protocol. The field is a String: a value Centrifugo
+    # sends or accepts which these do not name is still a valid one.
+
+    # The Protocol "json".
+    PROTOCOL_JSON = "json"
+
+    # The Protocol "protobuf".
+    PROTOCOL_PROTOBUF = "protobuf"
+
+    # The values of ConnectRequest.encoding, RefreshRequest.encoding,
+    # SubscribeRequest.encoding, PublishRequest.encoding,
+    # MapPublishRequest.encoding, MapRemoveRequest.encoding, RPCRequest.encoding
+    # and SubRefreshRequest.encoding. The field is a String: a value Centrifugo
+    # sends or accepts which these do not name is still a valid one.
+
+    # The Encoding "json".
+    ENCODING_JSON = "json"
+
+    # The Encoding "binary".
+    ENCODING_BINARY = "binary"
+
+    # The values of ChannelsCapability.allow and SubscribeResult.allow. The field
+    # is a String: a value Centrifugo sends or accepts which these do not name is
+    # still a valid one.
+
+    # The Allow "sub".
+    ALLOW_SUB = "sub"
+
+    # The Allow "pub".
+    ALLOW_PUB = "pub"
+
+    # The Allow "hst".
+    ALLOW_HST = "hst"
+
+    # The Allow "prs".
+    ALLOW_PRS = "prs"
+
+    # The values of ChannelsCapability.match. The field is a String: a value
+    # Centrifugo sends or accepts which these do not name is still a valid one.
+
+    # The CapabilityMatch "wildcard".
+    CAPABILITY_MATCH_WILDCARD = "wildcard"
+
+    # The CapabilityMatch "regex".
+    CAPABILITY_MATCH_REGEX = "regex"
+
+    # The values of MapPublishResult.key_mode. The field is a String: a value
+    # Centrifugo sends or accepts which these do not name is still a valid one.
+
+    # The KeyMode "if_new".
+    KEY_MODE_IF_NEW = "if_new"
+
+    # The KeyMode "if_exists".
+    KEY_MODE_IF_EXISTS = "if_exists"
+
+    # The values of ChannelEvent.type. The field is a String: a value Centrifugo
+    # sends or accepts which these do not name is still a valid one.
+
+    # The ChannelEventType "occupied".
+    CHANNEL_EVENT_TYPE_OCCUPIED = "occupied"
+
+    # The ChannelEventType "vacated".
+    CHANNEL_EVENT_TYPE_VACATED = "vacated"
+  end
+end