cent 4.0.0 → 5.0.0

data/lib/cent/generated/types.rb

@@ -0,0 +1,2844 @@
+# frozen_string_literal: true
+
+# Code generated by gen/generate.rb from proto/api.proto. DO NOT EDIT.
+
+module Cent
+  # PublishResult is the result of a successful publish.
+  #
+  # @!attribute [r] offset
+  #   @return [Integer] The offset of the publication in the channel history stream.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the channel history stream.
+  class PublishResult < Data.define(:offset, :epoch)
+    include Message
+
+    def initialize(offset: 0, 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, "offset", offset, where, :int)
+      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 = "PublishResult")
+      d = Wire.obj(v, where)
+      new(
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str)
+      )
+    end
+  end
+
+  # FilterNode is a tree describing a predicate over client labels. Used as
+  # label_filter on Subscribe, Unsubscribe, Disconnect, Refresh and
+  # Connections requests. A node is either a leaf comparison (key, cmp, val or
+  # vals) or a logical operation (op) over child nodes.
+  # Centrifugo PRO only: defined here for protocol-surface consistency,
+  # Centrifugo OSS parses it but ignores it.
+  #
+  # @!attribute [r] op
+  #   @return [String] The logical operation of a non-leaf node. Empty for a leaf node.
+  #     One of: and, or, not.
+  # @!attribute [r] key
+  #   @return [String] The label key a leaf node compares.
+  # @!attribute [r] cmp
+  #   @return [String] The comparison of a leaf node. One of: eq, neq, in, nin, ex, nex,
+  #     sw, ew, ct, gt, gte, lt, lte.
+  # @!attribute [r] val
+  #   @return [String] The value to compare with, for single-value comparisons.
+  # @!attribute [r] vals
+  #   @return [Array<String>] The values to compare with, for "in" and "nin".
+  # @!attribute [r] nodes
+  #   @return [Array<FilterNode>] The child nodes of a logical operation.
+  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
+
+  # SubscribeOptionOverride overrides channel options for a server-side
+  # subscription. Unset fields keep the value from the channel configuration.
+  #
+  # @!attribute [r] presence
+  #   @return [Boolean, nil] Overrides the presence channel option.
+  # @!attribute [r] join_leave
+  #   @return [Boolean, nil] Overrides the join_leave channel option.
+  # @!attribute [r] force_recovery
+  #   @return [Boolean, nil] Overrides the force_recovery channel option.
+  # @!attribute [r] force_positioning
+  #   @return [Boolean, nil] Overrides the force_positioning channel option.
+  # @!attribute [r] force_push_join_leave
+  #   @return [Boolean, nil] Overrides the force_push_join_leave channel
+  #     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 is the result of a subscribe call. Empty at the moment.
+  class SubscribeResult < 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 = "SubscribeResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # UnsubscribeResult is the result of an unsubscribe call. Empty at the
+  # moment.
+  class UnsubscribeResult < 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 = "UnsubscribeResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # Disconnect describes the code and reason clients are disconnected with.
+  #
+  # @!attribute [r] code
+  #   @return [Integer] The disconnect code.
+  # @!attribute [r] reason
+  #   @return [String] The disconnect reason.
+  class Disconnect < Data.define(:code, :reason)
+    include Message
+
+    def initialize(code: 0, reason: "") = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "code", code, where, :int)
+      Wire.put(w, "reason", reason, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "Disconnect")
+      d = Wire.obj(v, where)
+      new(
+        code: Wire.get(d, "code", where, :int),
+        reason: Wire.get(d, "reason", where, :str)
+      )
+    end
+  end
+
+  # DisconnectResult is the result of a disconnect call. Empty at the moment.
+  class DisconnectResult < 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 = "DisconnectResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # ClientInfo describes a client connection.
+  #
+  # @!attribute [r] user
+  #   @return [String] The user ID.
+  # @!attribute [r] client
+  #   @return [String] The client ID.
+  # @!attribute [r] conn_info
+  #   @return [Object, nil] Optional connection info.
+  # @!attribute [r] chan_info
+  #   @return [Object, nil] Optional channel info.
+  class ClientInfo < Data.define(:user, :client, :conn_info, :chan_info)
+    include Message
+
+    def initialize(
+      user: "",
+      client: "",
+      conn_info: nil,
+      chan_info: 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, "user", user, where, :str)
+      Wire.put(w, "client", client, where, :str)
+      Wire.put(w, "conn_info", conn_info, where, :json)
+      Wire.put(w, "chan_info", chan_info, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ClientInfo")
+      d = Wire.obj(v, where)
+      new(
+        user: Wire.get(d, "user", where, :str),
+        client: Wire.get(d, "client", where, :str),
+        conn_info: Wire.get(d, "conn_info", where, :json),
+        chan_info: Wire.get(d, "chan_info", where, :json)
+      )
+    end
+  end
+
+  # PresenceResult is the result of a presence call.
+  #
+  # @!attribute [r] presence
+  #   @return [Hash{String => ClientInfo}] Maps client ID to information about the client.
+  class PresenceResult < Data.define(:presence)
+    include Message
+
+    def initialize(presence: {}) = super
+
+    # 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, ClientInfo, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PresenceResult")
+      d = Wire.obj(v, where)
+      new(
+        presence: Wire.get(d, "presence", where, ClientInfo, :map)
+      )
+    end
+  end
+
+  # PresenceStatsResult is the result of a presence stats call.
+  #
+  # @!attribute [r] num_clients
+  #   @return [Integer] The total number of clients in the channel.
+  # @!attribute [r] num_users
+  #   @return [Integer] The number of unique users in the channel.
+  class PresenceStatsResult < Data.define(:num_clients, :num_users)
+    include Message
+
+    def initialize(num_clients: 0, num_users: 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, "num_clients", num_clients, where, :int)
+      Wire.put(w, "num_users", num_users, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PresenceStatsResult")
+      d = Wire.obj(v, where)
+      new(
+        num_clients: Wire.get(d, "num_clients", where, :int),
+        num_users: Wire.get(d, "num_users", where, :int)
+      )
+    end
+  end
+
+  # StreamPosition is a position in a channel stream.
+  #
+  # @!attribute [r] offset
+  #   @return [Integer] The offset in the stream.
+  # @!attribute [r] epoch
+  #   @return [String] The stream epoch.
+  class StreamPosition < Data.define(:offset, :epoch)
+    include Message
+
+    def initialize(offset: 0, 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, "offset", offset, where, :int)
+      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 = "StreamPosition")
+      d = Wire.obj(v, where)
+      new(
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str)
+      )
+    end
+  end
+
+  # Publication is a publication in a channel history.
+  #
+  # @!attribute [r] data
+  #   @return [Object, nil] The publication payload.
+  # @!attribute [r] info
+  #   @return [ClientInfo, nil] Information about the client that published, if any.
+  # @!attribute [r] offset
+  #   @return [Integer] The offset of the publication in the history stream.
+  # @!attribute [r] tags
+  #   @return [Hash{String => String}] The publication tags.
+  class Publication < Data.define(:data, :info, :offset, :tags)
+    include Message
+
+    def initialize(
+      data: nil,
+      info: nil,
+      offset: 0,
+      tags: {}
+    )
+      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, "info", info, where, ClientInfo)
+      Wire.put(w, "offset", offset, where, :int)
+      Wire.put(w, "tags", tags, where, :str, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "Publication")
+      d = Wire.obj(v, where)
+      new(
+        data: Wire.get(d, "data", where, :json),
+        info: Wire.get(d, "info", where, ClientInfo),
+        offset: Wire.get(d, "offset", where, :int),
+        tags: Wire.get(d, "tags", where, :str, :map)
+      )
+    end
+  end
+
+  # HistoryResult is the result of a history call.
+  #
+  # @!attribute [r] publications
+  #   @return [Array<Publication>] The list of publications.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the current stream.
+  # @!attribute [r] offset
+  #   @return [Integer] The top offset of the history stream.
+  class HistoryResult < Data.define(:publications, :epoch, :offset)
+    include Message
+
+    def initialize(publications: [], epoch: "", offset: 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, "publications", publications, where, Publication, :list)
+      Wire.put(w, "epoch", epoch, where, :str)
+      Wire.put(w, "offset", offset, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "HistoryResult")
+      d = Wire.obj(v, where)
+      new(
+        publications: Wire.get(d, "publications", where, Publication, :list),
+        epoch: Wire.get(d, "epoch", where, :str),
+        offset: Wire.get(d, "offset", where, :int)
+      )
+    end
+  end
+
+  # HistoryRemoveResult is the result of a history remove call. Empty at the
+  # moment.
+  class HistoryRemoveResult < 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 = "HistoryRemoveResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # InfoResult is the result of an info call.
+  #
+  # @!attribute [r] nodes
+  #   @return [Array<NodeResult>] Information about all nodes of the cluster.
+  class InfoResult < Data.define(:nodes)
+    include Message
+
+    def initialize(nodes: []) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "nodes", nodes, where, NodeResult, :list)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "InfoResult")
+      d = Wire.obj(v, where)
+      new(
+        nodes: Wire.get(d, "nodes", where, NodeResult, :list)
+      )
+    end
+  end
+
+  # RefreshResult is the result of a refresh call. Empty at the moment.
+  class RefreshResult < 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 = "RefreshResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # NodeResult is information about a Centrifugo node.
+  #
+  # @!attribute [r] uid
+  #   @return [String] The unique ID of the node.
+  # @!attribute [r] name
+  #   @return [String] The node name.
+  # @!attribute [r] version
+  #   @return [String] The Centrifugo version of the node.
+  # @!attribute [r] num_clients
+  #   @return [Integer] The number of clients connected to the node.
+  # @!attribute [r] num_users
+  #   @return [Integer] The number of unique users connected to the node.
+  # @!attribute [r] num_channels
+  #   @return [Integer] The number of active channels on the node.
+  # @!attribute [r] uptime
+  #   @return [Integer] The node uptime in seconds.
+  # @!attribute [r] metrics
+  #   @return [Metrics, nil] Aggregated node metrics, if available.
+  # @!attribute [r] process
+  #   @return [Process, nil] CPU and memory usage of the node process.
+  #     Centrifugo PRO only.
+  # @!attribute [r] num_subs
+  #   @return [Integer] The number of subscriptions on the node.
+  class NodeResult < Data.define(:uid, :name, :version, :num_clients, :num_users, :num_channels, :uptime, :metrics, :process, :num_subs)
+    include Message
+
+    def initialize(
+      uid: "",
+      name: "",
+      version: "",
+      num_clients: 0,
+      num_users: 0,
+      num_channels: 0,
+      uptime: 0,
+      metrics: nil,
+      process: nil,
+      num_subs: 0
+    )
+      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, "uid", uid, where, :str)
+      Wire.put(w, "name", name, where, :str)
+      Wire.put(w, "version", version, where, :str)
+      Wire.put(w, "num_clients", num_clients, where, :int)
+      Wire.put(w, "num_users", num_users, where, :int)
+      Wire.put(w, "num_channels", num_channels, where, :int)
+      Wire.put(w, "uptime", uptime, where, :int)
+      Wire.put(w, "metrics", metrics, where, Metrics)
+      Wire.put(w, "process", process, where, Process)
+      Wire.put(w, "num_subs", num_subs, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "NodeResult")
+      d = Wire.obj(v, where)
+      new(
+        uid: Wire.get(d, "uid", where, :str),
+        name: Wire.get(d, "name", where, :str),
+        version: Wire.get(d, "version", where, :str),
+        num_clients: Wire.get(d, "num_clients", where, :int),
+        num_users: Wire.get(d, "num_users", where, :int),
+        num_channels: Wire.get(d, "num_channels", where, :int),
+        uptime: Wire.get(d, "uptime", where, :int),
+        metrics: Wire.get(d, "metrics", where, Metrics),
+        process: Wire.get(d, "process", where, Process),
+        num_subs: Wire.get(d, "num_subs", where, :int)
+      )
+    end
+  end
+
+  # Metrics are aggregated metrics of a node.
+  #
+  # @!attribute [r] interval
+  #   @return [Float] The metrics aggregation interval in seconds.
+  # @!attribute [r] items
+  #   @return [Hash{String => Float}] Maps metric name to value.
+  class Metrics < Data.define(:interval, :items)
+    include Message
+
+    def initialize(interval: 0.0, 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, "interval", interval, where, :float)
+      Wire.put(w, "items", items, where, :float, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "Metrics")
+      d = Wire.obj(v, where)
+      new(
+        interval: Wire.get(d, "interval", where, :float),
+        items: Wire.get(d, "items", where, :float, :map)
+      )
+    end
+  end
+
+  # Process is resource usage of a node process. Centrifugo PRO only.
+  #
+  # @!attribute [r] cpu
+  #   @return [Float] The CPU usage of the process in percent.
+  # @!attribute [r] rss
+  #   @return [Integer] The resident set size of the process in bytes.
+  class Process < Data.define(:cpu, :rss)
+    include Message
+
+    def initialize(cpu: 0.0, rss: 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, "cpu", cpu, where, :float)
+      Wire.put(w, "rss", rss, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "Process")
+      d = Wire.obj(v, where)
+      new(
+        cpu: Wire.get(d, "cpu", where, :float),
+        rss: Wire.get(d, "rss", where, :int)
+      )
+    end
+  end
+
+  # ChannelsResult is the result of a channels call.
+  #
+  # @!attribute [r] channels
+  #   @return [Hash{String => ChannelInfo}] Maps channel name to information about the channel.
+  class ChannelsResult < Data.define(:channels)
+    include Message
+
+    def initialize(channels: {}) = 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, ChannelInfo, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ChannelsResult")
+      d = Wire.obj(v, where)
+      new(
+        channels: Wire.get(d, "channels", where, ChannelInfo, :map)
+      )
+    end
+  end
+
+  # ChannelInfo is information about an active channel.
+  #
+  # @!attribute [r] num_clients
+  #   @return [Integer] The number of connections subscribed to the channel.
+  class ChannelInfo < Data.define(:num_clients)
+    include Message
+
+    def initialize(num_clients: 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, "num_clients", num_clients, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ChannelInfo")
+      d = Wire.obj(v, where)
+      new(
+        num_clients: Wire.get(d, "num_clients", where, :int)
+      )
+    end
+  end
+
+  # ConnectionsResult is the result of a connections call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] connections
+  #   @return [Hash{String => ConnectionInfo}] Maps client ID to information about the connection.
+  class ConnectionsResult < Data.define(:connections)
+    include Message
+
+    def initialize(connections: {}) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "connections", connections, where, ConnectionInfo, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ConnectionsResult")
+      d = Wire.obj(v, where)
+      new(
+        connections: Wire.get(d, "connections", where, ConnectionInfo, :map)
+      )
+    end
+  end
+
+  # ConnectionInfo is information about a client connection.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] app_name
+  #   @return [String] The client application name, if provided by the client.
+  # @!attribute [r] app_version
+  #   @return [String] The client application version, if provided by the
+  #     client.
+  # @!attribute [r] transport
+  #   @return [String] The name of the connection transport.
+  # @!attribute [r] protocol
+  #   @return [String] The connection protocol: json or protobuf.
+  # @!attribute [r] user
+  #   @return [String] The user ID of the connection.
+  # @!attribute [r] state
+  #   @return [ConnectionState, nil] The connection state.
+  # @!attribute [r] connected_at_ms
+  #   @return [Integer] The Unix time in milliseconds when the connection
+  #     was established.
+  # @!attribute [r] ping_pong_latency_ms
+  #   @return [Integer] The last measured client ping/pong round-trip
+  #     latency in milliseconds. Can be -1 if not available.
+  # @!attribute [r] labels
+  #   @return [Hash{String => String}] The client labels attached to the connection.
+  class ConnectionInfo < Data.define(:app_name, :app_version, :transport, :protocol, :user, :state, :connected_at_ms, :ping_pong_latency_ms, :labels)
+    include Message
+
+    def initialize(
+      app_name: "",
+      app_version: "",
+      transport: "",
+      protocol: "",
+      user: "",
+      state: nil,
+      connected_at_ms: 0,
+      ping_pong_latency_ms: 0,
+      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, "app_name", app_name, where, :str)
+      Wire.put(w, "app_version", app_version, where, :str)
+      Wire.put(w, "transport", transport, where, :str)
+      Wire.put(w, "protocol", protocol, where, :str)
+      Wire.put(w, "user", user, where, :str)
+      Wire.put(w, "state", state, where, ConnectionState)
+      Wire.put(w, "connected_at_ms", connected_at_ms, where, :int)
+      Wire.put(w, "ping_pong_latency_ms", ping_pong_latency_ms, where, :int)
+      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 = "ConnectionInfo")
+      d = Wire.obj(v, where)
+      new(
+        app_name: Wire.get(d, "app_name", where, :str),
+        app_version: Wire.get(d, "app_version", where, :str),
+        transport: Wire.get(d, "transport", where, :str),
+        protocol: Wire.get(d, "protocol", where, :str),
+        user: Wire.get(d, "user", where, :str),
+        state: Wire.get(d, "state", where, ConnectionState),
+        connected_at_ms: Wire.get(d, "connected_at_ms", where, :int),
+        ping_pong_latency_ms: Wire.get(d, "ping_pong_latency_ms", where, :int),
+        labels: Wire.get(d, "labels", where, :str, :map)
+      )
+    end
+  end
+
+  # ConnectionState is the state of a client connection.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] channels
+  #   @return [Hash{String => ChannelContext}] Maps the channels the client is subscribed to to their
+  #     context.
+  # @!attribute [r] connection_token
+  #   @return [ConnectionTokenInfo, nil] Information about the connection token.
+  # @!attribute [r] subscription_tokens
+  #   @return [Hash{String => SubscriptionTokenInfo}] Maps channel to information about the subscription
+  #     token used to subscribe to it.
+  # @!attribute [r] meta
+  #   @return [Object, nil] The meta information attached to the connection. It is not
+  #     visible to other clients: Centrifugo never sends it. Meta from a
+  #     connection token is visible to the user owning the token, though: it
+  #     must not hold anything that user must not see.
+  class ConnectionState < Data.define(:channels, :connection_token, :subscription_tokens, :meta)
+    include Message
+
+    def initialize(
+      channels: {},
+      connection_token: nil,
+      subscription_tokens: {},
+      meta: 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, "channels", channels, where, ChannelContext, :map)
+      Wire.put(w, "connection_token", connection_token, where, ConnectionTokenInfo)
+      Wire.put(w, "subscription_tokens", subscription_tokens, where, SubscriptionTokenInfo, :map)
+      Wire.put(w, "meta", meta, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ConnectionState")
+      d = Wire.obj(v, where)
+      new(
+        channels: Wire.get(d, "channels", where, ChannelContext, :map),
+        connection_token: Wire.get(d, "connection_token", where, ConnectionTokenInfo),
+        subscription_tokens: Wire.get(d, "subscription_tokens", where, SubscriptionTokenInfo, :map),
+        meta: Wire.get(d, "meta", where, :json)
+      )
+    end
+  end
+
+  # ChannelContext is context of a channel subscription.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] source
+  #   @return [Integer] The source of the channel subscription (for example,
+  #     subscription token, subscribe proxy or server API).
+  class ChannelContext < Data.define(:source)
+    include Message
+
+    def initialize(source: 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, "source", source, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ChannelContext")
+      d = Wire.obj(v, where)
+      new(
+        source: Wire.get(d, "source", where, :int)
+      )
+    end
+  end
+
+  # ConnectionTokenInfo is information about a connection token.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] uid
+  #   @return [String] The unique token ID (jti claim).
+  # @!attribute [r] issued_at
+  #   @return [Integer] The Unix time in seconds when the token was issued.
+  class ConnectionTokenInfo < Data.define(:uid, :issued_at)
+    include Message
+
+    def initialize(uid: "", issued_at: 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, "uid", uid, where, :str)
+      Wire.put(w, "issued_at", issued_at, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ConnectionTokenInfo")
+      d = Wire.obj(v, where)
+      new(
+        uid: Wire.get(d, "uid", where, :str),
+        issued_at: Wire.get(d, "issued_at", where, :int)
+      )
+    end
+  end
+
+  # SubscriptionTokenInfo is information about a subscription token.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] uid
+  #   @return [String] The unique token ID (jti claim).
+  # @!attribute [r] issued_at
+  #   @return [Integer] The Unix time in seconds when the token was issued.
+  class SubscriptionTokenInfo < Data.define(:uid, :issued_at)
+    include Message
+
+    def initialize(uid: "", issued_at: 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, "uid", uid, where, :str)
+      Wire.put(w, "issued_at", issued_at, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "SubscriptionTokenInfo")
+      d = Wire.obj(v, where)
+      new(
+        uid: Wire.get(d, "uid", where, :str),
+        issued_at: Wire.get(d, "issued_at", where, :int)
+      )
+    end
+  end
+
+  # UpdateUserStatusResult is the result of an update user status call. Empty
+  # at the moment. Centrifugo PRO only.
+  class UpdateUserStatusResult < 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 = "UpdateUserStatusResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # GetUserStatusResult is the result of a get user status call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] statuses
+  #   @return [Array<UserStatus>] The statuses of the requested users, in the same order.
+  class GetUserStatusResult < Data.define(:statuses)
+    include Message
+
+    def initialize(statuses: []) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "statuses", statuses, where, UserStatus, :list)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "GetUserStatusResult")
+      d = Wire.obj(v, where)
+      new(
+        statuses: Wire.get(d, "statuses", where, UserStatus, :list)
+      )
+    end
+  end
+
+  # UserStatus is the status of a user. Centrifugo PRO only.
+  #
+  # @!attribute [r] user
+  #   @return [String] The user ID.
+  # @!attribute [r] active
+  #   @return [Integer] The last active time as Unix seconds. Not set if unknown.
+  # @!attribute [r] online
+  #   @return [Integer] The last online time as Unix seconds, updated by Centrifugo
+  #     while the user is connected. Not set if unknown.
+  # @!attribute [r] state
+  #   @return [String] The custom state set with UpdateUserStatusRequest.state, if
+  #     any.
+  class UserStatus < Data.define(:user, :active, :online, :state)
+    include Message
+
+    def initialize(
+      user: "",
+      active: 0,
+      online: 0,
+      state: ""
+    )
+      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, "active", active, where, :int)
+      Wire.put(w, "online", online, where, :int)
+      Wire.put(w, "state", state, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "UserStatus")
+      d = Wire.obj(v, where)
+      new(
+        user: Wire.get(d, "user", where, :str),
+        active: Wire.get(d, "active", where, :int),
+        online: Wire.get(d, "online", where, :int),
+        state: Wire.get(d, "state", where, :str)
+      )
+    end
+  end
+
+  # DeleteUserStatusResult is the result of a delete user status call. Empty
+  # at the moment. Centrifugo PRO only.
+  class DeleteUserStatusResult < 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 = "DeleteUserStatusResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # BlockUserResult is the result of a block user call. Empty at the moment.
+  # Centrifugo PRO only.
+  class BlockUserResult < 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 = "BlockUserResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # UnblockUserResult is the result of an unblock user call. Empty at the
+  # moment. Centrifugo PRO only.
+  class UnblockUserResult < 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 = "UnblockUserResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # RevokeTokenResult is the result of a revoke token call. Empty at the
+  # moment. Centrifugo PRO only.
+  class RevokeTokenResult < 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 = "RevokeTokenResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # InvalidateUserTokensResult is the result of an invalidate user tokens
+  # call. Empty at the moment. Centrifugo PRO only.
+  class InvalidateUserTokensResult < 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 = "InvalidateUserTokensResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # DeviceUserUpdate sets the user of devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] user
+  #   @return [String] The user ID to set. Required. "" detaches the devices from their
+  #     user.
+  class DeviceUserUpdate < Data.define(:user)
+    include Message
+
+    # 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)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceUserUpdate")
+      d = Wire.obj(v, where)
+      new(
+        user: Wire.get(d, "user", where, :str)
+      )
+    end
+  end
+
+  # DeviceTimezoneUpdate sets the timezone of devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] timezone
+  #   @return [String] The IANA time zone to set. Required. "" clears it.
+  class DeviceTimezoneUpdate < Data.define(:timezone)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "timezone", timezone, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceTimezoneUpdate")
+      d = Wire.obj(v, where)
+      new(
+        timezone: Wire.get(d, "timezone", where, :str)
+      )
+    end
+  end
+
+  # DeviceLocaleUpdate sets the locale of devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] locale
+  #   @return [String] The locale to set. Required. "" clears it.
+  class DeviceLocaleUpdate < Data.define(:locale)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "locale", locale, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceLocaleUpdate")
+      d = Wire.obj(v, where)
+      new(
+        locale: Wire.get(d, "locale", where, :str)
+      )
+    end
+  end
+
+  # DeviceMetaUpdate sets the meta of devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] meta
+  #   @return [Hash{String => String}] The meta to set. Required. An empty map clears it.
+  class DeviceMetaUpdate < Data.define(:meta)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "meta", meta, where, :str, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceMetaUpdate")
+      d = Wire.obj(v, where)
+      new(
+        meta: Wire.get(d, "meta", where, :str, :map)
+      )
+    end
+  end
+
+  # DeviceTopicsUpdate changes the topics of devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] op
+  #   @return [String] The operation. Required. One of: add, remove, set.
+  # @!attribute [r] topics
+  #   @return [Array<String>] The topics for the operation.
+  class DeviceTopicsUpdate < Data.define(:op, :topics)
+    include Message
+
+    def initialize(op:, topics: []) = super
+
+    # 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, "topics", topics, where, :str, :list)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceTopicsUpdate")
+      d = Wire.obj(v, where)
+      new(
+        op: Wire.get(d, "op", where, :str),
+        topics: Wire.get(d, "topics", where, :str, :list)
+      )
+    end
+  end
+
+  # DeviceFilter selects devices. Centrifugo PRO only.
+  #
+  # @!attribute [r] ids
+  #   @return [Array<String>] Selects devices by ID.
+  # @!attribute [r] users
+  #   @return [Array<String>] Selects devices by user.
+  # @!attribute [r] topics
+  #   @return [Array<String>] Selects devices by subscribed topic.
+  # @!attribute [r] providers
+  #   @return [Array<String>] Selects devices by token provider.
+  # @!attribute [r] platforms
+  #   @return [Array<String>] Selects devices by platform.
+  class DeviceFilter < Data.define(:ids, :users, :topics, :providers, :platforms)
+    include Message
+
+    def initialize(
+      ids: [],
+      users: [],
+      topics: [],
+      providers: [],
+      platforms: []
+    )
+      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, "ids", ids, where, :str, :list)
+      Wire.put(w, "users", users, where, :str, :list)
+      Wire.put(w, "topics", topics, where, :str, :list)
+      Wire.put(w, "providers", providers, where, :str, :list)
+      Wire.put(w, "platforms", platforms, where, :str, :list)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceFilter")
+      d = Wire.obj(v, where)
+      new(
+        ids: Wire.get(d, "ids", where, :str, :list),
+        users: Wire.get(d, "users", where, :str, :list),
+        topics: Wire.get(d, "topics", where, :str, :list),
+        providers: Wire.get(d, "providers", where, :str, :list),
+        platforms: Wire.get(d, "platforms", where, :str, :list)
+      )
+    end
+  end
+
+  # DeviceTopicFilter selects device topic subscriptions. Centrifugo PRO only.
+  #
+  # @!attribute [r] device_ids
+  #   @return [Array<String>] Selects by device ID.
+  # @!attribute [r] device_providers
+  #   @return [Array<String>] Selects by device token provider.
+  # @!attribute [r] device_platforms
+  #   @return [Array<String>] Selects by device platform.
+  # @!attribute [r] device_users
+  #   @return [Array<String>] Selects by device user.
+  # @!attribute [r] topics
+  #   @return [Array<String>] Selects by topic.
+  # @!attribute [r] topic_prefix
+  #   @return [String] Selects by topic prefix.
+  class DeviceTopicFilter < Data.define(:device_ids, :device_providers, :device_platforms, :device_users, :topics, :topic_prefix)
+    include Message
+
+    def initialize(
+      device_ids: [],
+      device_providers: [],
+      device_platforms: [],
+      device_users: [],
+      topics: [],
+      topic_prefix: ""
+    )
+      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, "device_ids", device_ids, where, :str, :list)
+      Wire.put(w, "device_providers", device_providers, where, :str, :list)
+      Wire.put(w, "device_platforms", device_platforms, where, :str, :list)
+      Wire.put(w, "device_users", device_users, where, :str, :list)
+      Wire.put(w, "topics", topics, where, :str, :list)
+      Wire.put(w, "topic_prefix", topic_prefix, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceTopicFilter")
+      d = Wire.obj(v, where)
+      new(
+        device_ids: Wire.get(d, "device_ids", where, :str, :list),
+        device_providers: Wire.get(d, "device_providers", where, :str, :list),
+        device_platforms: Wire.get(d, "device_platforms", where, :str, :list),
+        device_users: Wire.get(d, "device_users", where, :str, :list),
+        topics: Wire.get(d, "topics", where, :str, :list),
+        topic_prefix: Wire.get(d, "topic_prefix", where, :str)
+      )
+    end
+  end
+
+  # UserTopicFilter selects user topic subscriptions. Centrifugo PRO only.
+  #
+  # @!attribute [r] users
+  #   @return [Array<String>] Selects by user.
+  # @!attribute [r] topics
+  #   @return [Array<String>] Selects by topic.
+  # @!attribute [r] topic_prefix
+  #   @return [String] Selects by topic prefix.
+  class UserTopicFilter < Data.define(:users, :topics, :topic_prefix)
+    include Message
+
+    def initialize(users: [], topics: [], topic_prefix: "") = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "users", users, where, :str, :list)
+      Wire.put(w, "topics", topics, where, :str, :list)
+      Wire.put(w, "topic_prefix", topic_prefix, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "UserTopicFilter")
+      d = Wire.obj(v, where)
+      new(
+        users: Wire.get(d, "users", where, :str, :list),
+        topics: Wire.get(d, "topics", where, :str, :list),
+        topic_prefix: Wire.get(d, "topic_prefix", where, :str)
+      )
+    end
+  end
+
+  # DeviceRegisterResult is the result of a device register call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] id
+  #   @return [String] The ID of the registered or updated device.
+  class DeviceRegisterResult < Data.define(:id)
+    include Message
+
+    def initialize(id: "") = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "id", id, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceRegisterResult")
+      d = Wire.obj(v, where)
+      new(
+        id: Wire.get(d, "id", where, :str)
+      )
+    end
+  end
+
+  # DeviceUpdateResult is the result of a device update call. Empty at the
+  # moment. Centrifugo PRO only.
+  class DeviceUpdateResult < 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 = "DeviceUpdateResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # DeviceRemoveResult is the result of a device remove call. Empty at the
+  # moment. Centrifugo PRO only.
+  class DeviceRemoveResult < 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 = "DeviceRemoveResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # DeviceListResult is the result of a device list call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] items
+  #   @return [Array<Device>] The devices of this page.
+  # @!attribute [r] next_cursor
+  #   @return [String] The cursor of the next page. Empty if there is no next
+  #     page.
+  # @!attribute [r] total_count
+  #   @return [Integer] The total count for the filter, if include_total_count
+  #     was set.
+  class DeviceListResult < Data.define(:items, :next_cursor, :total_count)
+    include Message
+
+    def initialize(items: [], next_cursor: "", total_count: 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, "items", items, where, Device, :list)
+      Wire.put(w, "next_cursor", next_cursor, where, :str)
+      Wire.put(w, "total_count", total_count, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceListResult")
+      d = Wire.obj(v, where)
+      new(
+        items: Wire.get(d, "items", where, Device, :list),
+        next_cursor: Wire.get(d, "next_cursor", where, :str),
+        total_count: Wire.get(d, "total_count", where, :int)
+      )
+    end
+  end
+
+  # Device is a device registered for push notifications. Centrifugo PRO only.
+  #
+  # @!attribute [r] id
+  #   @return [String] The device ID.
+  # @!attribute [r] platform
+  #   @return [String] The device platform.
+  # @!attribute [r] provider
+  #   @return [String] The device token provider.
+  # @!attribute [r] token
+  #   @return [String] The device token. For webpush, it is the subscription
+  #     endpoint.
+  # @!attribute [r] user
+  #   @return [String] The user associated with the device.
+  # @!attribute [r] created_at
+  #   @return [Integer] The Unix time in milliseconds when the device was
+  #     created.
+  # @!attribute [r] updated_at
+  #   @return [Integer] The Unix time in milliseconds when the device was last
+  #     updated.
+  # @!attribute [r] meta
+  #   @return [Hash{String => String}] The device meta. Only set if include_meta was requested.
+  # @!attribute [r] topics
+  #   @return [Array<String>] The device topics. Only set if include_topics was
+  #     requested.
+  # @!attribute [r] timezone
+  #   @return [String] The device timezone.
+  # @!attribute [r] locale
+  #   @return [String] The device locale.
+  # @!attribute [r] webpush_keys
+  #   @return [String] The Web Push subscription keys JSON ({p256dh, auth}).
+  #     Only set if include_webpush_keys was requested.
+  class Device < Data.define(:id, :platform, :provider, :token, :user, :created_at, :updated_at, :meta, :topics, :timezone, :locale, :webpush_keys)
+    include Message
+
+    def initialize(
+      id: "",
+      platform: "",
+      provider: "",
+      token: "",
+      user: "",
+      created_at: 0,
+      updated_at: 0,
+      meta: {},
+      topics: [],
+      timezone: "",
+      locale: "",
+      webpush_keys: ""
+    )
+      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, "id", id, where, :str)
+      Wire.put(w, "platform", platform, where, :str)
+      Wire.put(w, "provider", provider, where, :str)
+      Wire.put(w, "token", token, where, :str)
+      Wire.put(w, "user", user, where, :str)
+      Wire.put(w, "created_at", created_at, where, :int)
+      Wire.put(w, "updated_at", updated_at, where, :int)
+      Wire.put(w, "meta", meta, where, :str, :map)
+      Wire.put(w, "topics", topics, where, :str, :list)
+      Wire.put(w, "timezone", timezone, where, :str)
+      Wire.put(w, "locale", locale, where, :str)
+      Wire.put(w, "webpush_keys", webpush_keys, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "Device")
+      d = Wire.obj(v, where)
+      new(
+        id: Wire.get(d, "id", where, :str),
+        platform: Wire.get(d, "platform", where, :str),
+        provider: Wire.get(d, "provider", where, :str),
+        token: Wire.get(d, "token", where, :str),
+        user: Wire.get(d, "user", where, :str),
+        created_at: Wire.get(d, "created_at", where, :int),
+        updated_at: Wire.get(d, "updated_at", where, :int),
+        meta: Wire.get(d, "meta", where, :str, :map),
+        topics: Wire.get(d, "topics", where, :str, :list),
+        timezone: Wire.get(d, "timezone", where, :str),
+        locale: Wire.get(d, "locale", where, :str),
+        webpush_keys: Wire.get(d, "webpush_keys", where, :str)
+      )
+    end
+  end
+
+  # DeviceTopicListResult is the result of a device topic list call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] items
+  #   @return [Array<DeviceTopic>] The device topics of this page.
+  # @!attribute [r] next_cursor
+  #   @return [String] The cursor of the next page. Empty if there is no next
+  #     page.
+  # @!attribute [r] total_count
+  #   @return [Integer] The total count for the filter, if include_total_count
+  #     was set.
+  class DeviceTopicListResult < Data.define(:items, :next_cursor, :total_count)
+    include Message
+
+    def initialize(items: [], next_cursor: "", total_count: 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, "items", items, where, DeviceTopic, :list)
+      Wire.put(w, "next_cursor", next_cursor, where, :str)
+      Wire.put(w, "total_count", total_count, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceTopicListResult")
+      d = Wire.obj(v, where)
+      new(
+        items: Wire.get(d, "items", where, DeviceTopic, :list),
+        next_cursor: Wire.get(d, "next_cursor", where, :str),
+        total_count: Wire.get(d, "total_count", where, :int)
+      )
+    end
+  end
+
+  # DeviceTopic is a topic subscription of a device. Centrifugo PRO only.
+  #
+  # @!attribute [r] id
+  #   @return [String] The ID of the device topic.
+  # @!attribute [r] topic
+  #   @return [String] The topic.
+  # @!attribute [r] device
+  #   @return [Device, nil] The device. Only set if include_device was requested.
+  class DeviceTopic < Data.define(:id, :topic, :device)
+    include Message
+
+    def initialize(id: "", topic: "", device: nil) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "id", id, where, :str)
+      Wire.put(w, "topic", topic, where, :str)
+      Wire.put(w, "device", device, where, Device)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "DeviceTopic")
+      d = Wire.obj(v, where)
+      new(
+        id: Wire.get(d, "id", where, :str),
+        topic: Wire.get(d, "topic", where, :str),
+        device: Wire.get(d, "device", where, Device)
+      )
+    end
+  end
+
+  # UserTopicListResult is the result of a user topic list call.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] items
+  #   @return [Array<UserTopic>] The user topics of this page.
+  # @!attribute [r] next_cursor
+  #   @return [String] The cursor of the next page. Empty if there is no next
+  #     page.
+  # @!attribute [r] total_count
+  #   @return [Integer] The total count for the filter, if include_total_count
+  #     was set.
+  class UserTopicListResult < Data.define(:items, :next_cursor, :total_count)
+    include Message
+
+    def initialize(items: [], next_cursor: "", total_count: 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, "items", items, where, UserTopic, :list)
+      Wire.put(w, "next_cursor", next_cursor, where, :str)
+      Wire.put(w, "total_count", total_count, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "UserTopicListResult")
+      d = Wire.obj(v, where)
+      new(
+        items: Wire.get(d, "items", where, UserTopic, :list),
+        next_cursor: Wire.get(d, "next_cursor", where, :str),
+        total_count: Wire.get(d, "total_count", where, :int)
+      )
+    end
+  end
+
+  # DeviceTopicUpdateResult is the result of a device topic update call.
+  # Empty at the moment. Centrifugo PRO only.
+  class DeviceTopicUpdateResult < 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 = "DeviceTopicUpdateResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # UserTopicUpdateResult is the result of a user topic update call. Empty at
+  # the moment. Centrifugo PRO only.
+  class UserTopicUpdateResult < 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 = "UserTopicUpdateResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # UserTopic is a topic subscription of a user. Centrifugo PRO only.
+  #
+  # @!attribute [r] id
+  #   @return [String] The ID of the user topic.
+  # @!attribute [r] user
+  #   @return [String] The user ID.
+  # @!attribute [r] topic
+  #   @return [String] The topic.
+  class UserTopic < Data.define(:id, :user, :topic)
+    include Message
+
+    def initialize(id: "", user: "", topic: "") = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "id", id, where, :str)
+      Wire.put(w, "user", user, where, :str)
+      Wire.put(w, "topic", topic, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "UserTopic")
+      d = Wire.obj(v, where)
+      new(
+        id: Wire.get(d, "id", where, :str),
+        user: Wire.get(d, "user", where, :str),
+        topic: Wire.get(d, "topic", where, :str)
+      )
+    end
+  end
+
+  # PushRecipient describes who receives a push notification. Set only one
+  # of its fields. Centrifugo PRO only.
+  #
+  # @!attribute [r] filter
+  #   @return [DeviceFilter, nil] Sends to devices from Centrifugo device storage that match the
+  #     filter.
+  # @!attribute [r] fcm_tokens
+  #   @return [Array<String>] Sends to a list of FCM native tokens.
+  # @!attribute [r] fcm_topic
+  #   @return [String] Sends to an FCM native topic.
+  # @!attribute [r] fcm_condition
+  #   @return [String] Sends to an FCM native condition.
+  # @!attribute [r] hms_tokens
+  #   @return [Array<String>] Sends to a list of HMS native tokens.
+  # @!attribute [r] hms_topic
+  #   @return [String] Sends to an HMS native topic.
+  # @!attribute [r] hms_condition
+  #   @return [String] Sends to an HMS native condition.
+  # @!attribute [r] apns_tokens
+  #   @return [Array<String>] Sends to a list of APNs native tokens.
+  # @!attribute [r] webpush_tokens
+  #   @return [Array<String>] Sends to a list of raw Web Push subscriptions, each a
+  #     PushSubscription JSON string.
+  class PushRecipient < Data.define(:filter, :fcm_tokens, :fcm_topic, :fcm_condition, :hms_tokens, :hms_topic, :hms_condition, :apns_tokens, :webpush_tokens)
+    include Message
+
+    def initialize(
+      filter: nil,
+      fcm_tokens: [],
+      fcm_topic: "",
+      fcm_condition: "",
+      hms_tokens: [],
+      hms_topic: "",
+      hms_condition: "",
+      apns_tokens: [],
+      webpush_tokens: []
+    )
+      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, "filter", filter, where, DeviceFilter)
+      Wire.put(w, "fcm_tokens", fcm_tokens, where, :str, :list)
+      Wire.put(w, "fcm_topic", fcm_topic, where, :str)
+      Wire.put(w, "fcm_condition", fcm_condition, where, :str)
+      Wire.put(w, "hms_tokens", hms_tokens, where, :str, :list)
+      Wire.put(w, "hms_topic", hms_topic, where, :str)
+      Wire.put(w, "hms_condition", hms_condition, where, :str)
+      Wire.put(w, "apns_tokens", apns_tokens, where, :str, :list)
+      Wire.put(w, "webpush_tokens", webpush_tokens, where, :str, :list)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushRecipient")
+      d = Wire.obj(v, where)
+      new(
+        filter: Wire.get(d, "filter", where, DeviceFilter),
+        fcm_tokens: Wire.get(d, "fcm_tokens", where, :str, :list),
+        fcm_topic: Wire.get(d, "fcm_topic", where, :str),
+        fcm_condition: Wire.get(d, "fcm_condition", where, :str),
+        hms_tokens: Wire.get(d, "hms_tokens", where, :str, :list),
+        hms_topic: Wire.get(d, "hms_topic", where, :str),
+        hms_condition: Wire.get(d, "hms_condition", where, :str),
+        apns_tokens: Wire.get(d, "apns_tokens", where, :str, :list),
+        webpush_tokens: Wire.get(d, "webpush_tokens", where, :str, :list)
+      )
+    end
+  end
+
+  # PushNotification is a push notification in the format of each provider.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] fcm
+  #   @return [FcmPushNotification, nil] The notification for FCM.
+  # @!attribute [r] hms
+  #   @return [HmsPushNotification, nil] The notification for HMS.
+  # @!attribute [r] apns
+  #   @return [ApnsPushNotification, nil] The notification for APNs.
+  # @!attribute [r] webpush
+  #   @return [WebPushPushNotification, nil] The notification for Web Push.
+  # @!attribute [r] expire_at
+  #   @return [Integer] The Unix time in seconds when Centrifugo stops trying to
+  #     send the notification. Not related to the providers' TTL fields.
+  #     Required when the request sets limit_strategy.
+  class PushNotification < Data.define(:fcm, :hms, :apns, :webpush, :expire_at)
+    include Message
+
+    def initialize(
+      fcm: nil,
+      hms: nil,
+      apns: nil,
+      webpush: nil,
+      expire_at: 0
+    )
+      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, "fcm", fcm, where, FcmPushNotification)
+      Wire.put(w, "hms", hms, where, HmsPushNotification)
+      Wire.put(w, "apns", apns, where, ApnsPushNotification)
+      Wire.put(w, "webpush", webpush, where, WebPushPushNotification)
+      Wire.put(w, "expire_at", expire_at, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushNotification")
+      d = Wire.obj(v, where)
+      new(
+        fcm: Wire.get(d, "fcm", where, FcmPushNotification),
+        hms: Wire.get(d, "hms", where, HmsPushNotification),
+        apns: Wire.get(d, "apns", where, ApnsPushNotification),
+        webpush: Wire.get(d, "webpush", where, WebPushPushNotification),
+        expire_at: Wire.get(d, "expire_at", where, :int)
+      )
+    end
+  end
+
+  # FcmPushNotification is a notification for FCM. Centrifugo PRO only.
+  #
+  # @!attribute [r] message
+  #   @return [Object, nil] The FCM Message object as JSON. Required.
+  class FcmPushNotification < Data.define(:message)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "message", message, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "FcmPushNotification")
+      d = Wire.obj(v, where)
+      new(
+        message: Wire.get(d, "message", where, :json)
+      )
+    end
+  end
+
+  # HmsPushNotification is a notification for HMS. Centrifugo PRO only.
+  #
+  # @!attribute [r] message
+  #   @return [Object, nil] The HMS Message object as JSON. Required.
+  class HmsPushNotification < Data.define(:message)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "message", message, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "HmsPushNotification")
+      d = Wire.obj(v, where)
+      new(
+        message: Wire.get(d, "message", where, :json)
+      )
+    end
+  end
+
+  # ApnsPushNotification is a notification for APNs. Centrifugo PRO only.
+  #
+  # @!attribute [r] headers
+  #   @return [Hash{String => String}] The APNs request headers.
+  # @!attribute [r] payload
+  #   @return [Object, nil] The APNs payload as JSON. Required.
+  class ApnsPushNotification < Data.define(:headers, :payload)
+    include Message
+
+    def initialize(payload:, headers: {}) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "headers", headers, where, :str, :map)
+      Wire.put(w, "payload", payload, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "ApnsPushNotification")
+      d = Wire.obj(v, where)
+      new(
+        headers: Wire.get(d, "headers", where, :str, :map),
+        payload: Wire.get(d, "payload", where, :json)
+      )
+    end
+  end
+
+  # WebPushPushNotification is a notification for Web Push.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] headers
+  #   @return [Hash{String => String}] Web Push HTTP headers. Recognized keys: TTL (seconds,
+  #     default 4 weeks), Urgency (very-low, low, normal, high) and Topic.
+  # @!attribute [r] payload
+  #   @return [Object, nil] The JSON payload delivered to the browser service worker.
+  #     Required.
+  class WebPushPushNotification < Data.define(:headers, :payload)
+    include Message
+
+    def initialize(payload:, headers: {}) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "headers", headers, where, :str, :map)
+      Wire.put(w, "payload", payload, where, :json)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "WebPushPushNotification")
+      d = Wire.obj(v, where)
+      new(
+        headers: Wire.get(d, "headers", where, :str, :map),
+        payload: Wire.get(d, "payload", where, :json)
+      )
+    end
+  end
+
+  # PushLocalization holds translations for one language/locale.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] translations
+  #   @return [Hash{String => String}] Maps variable name to value for the language/locale.
+  class PushLocalization < Data.define(:translations)
+    include Message
+
+    def initialize(translations: {}) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "translations", translations, where, :str, :map)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushLocalization")
+      d = Wire.obj(v, where)
+      new(
+        translations: Wire.get(d, "translations", where, :str, :map)
+      )
+    end
+  end
+
+  # PushLimitStrategy limits when and how often pushes are sent.
+  # Centrifugo PRO only.
+  #
+  # @!attribute [r] rate_limit
+  #   @return [PushRateLimitStrategy, nil] Sets rate limit policies.
+  # @!attribute [r] time_limit
+  #   @return [PushTimeLimitStrategy, nil] Sets a time limit policy based on the device timezone.
+  class PushLimitStrategy < Data.define(:rate_limit, :time_limit)
+    include Message
+
+    def initialize(rate_limit: nil, time_limit: nil) = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "rate_limit", rate_limit, where, PushRateLimitStrategy)
+      Wire.put(w, "time_limit", time_limit, where, PushTimeLimitStrategy)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushLimitStrategy")
+      d = Wire.obj(v, where)
+      new(
+        rate_limit: Wire.get(d, "rate_limit", where, PushRateLimitStrategy),
+        time_limit: Wire.get(d, "time_limit", where, PushTimeLimitStrategy)
+      )
+    end
+  end
+
+  # PushTimeLimitStrategy sends pushes within a window of the device local
+  # time. Centrifugo PRO only.
+  #
+  # @!attribute [r] send_after_time
+  #   @return [String] The local time, as HH:MM:SS, after which the push
+  #     may be sent. Required.
+  # @!attribute [r] send_before_time
+  #   @return [String] The local time, as HH:MM:SS, before which the push
+  #     must be sent. Required.
+  # @!attribute [r] no_tz_send_now
+  #   @return [Boolean] Sends the push immediately if the device timezone is
+  #     not set. By default such pushes are dropped.
+  class PushTimeLimitStrategy < Data.define(:send_after_time, :send_before_time, :no_tz_send_now)
+    include Message
+
+    def initialize(send_after_time:, send_before_time:, no_tz_send_now: 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, "send_after_time", send_after_time, where, :str)
+      Wire.put(w, "send_before_time", send_before_time, where, :str)
+      Wire.put(w, "no_tz_send_now", no_tz_send_now, where, :bool)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushTimeLimitStrategy")
+      d = Wire.obj(v, where)
+      new(
+        send_after_time: Wire.get(d, "send_after_time", where, :str),
+        send_before_time: Wire.get(d, "send_before_time", where, :str),
+        no_tz_send_now: Wire.get(d, "no_tz_send_now", where, :bool)
+      )
+    end
+  end
+
+  # PushRateLimitStrategy rate limits pushes per device. Centrifugo PRO only.
+  #
+  # @!attribute [r] key
+  #   @return [String] An optional key for the rate limit policy. Supports variables
+  #     (device.id and device.user).
+  # @!attribute [r] policies
+  #   @return [Array<RateLimitPolicy>] The rate limit policies to apply.
+  # @!attribute [r] drop_if_rate_limited
+  #   @return [Boolean] Drops a rate limited push instead of queuing it
+  #     for later.
+  class PushRateLimitStrategy < Data.define(:key, :policies, :drop_if_rate_limited)
+    include Message
+
+    def initialize(key: "", policies: [], drop_if_rate_limited: 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, "key", key, where, :str)
+      Wire.put(w, "policies", policies, where, RateLimitPolicy, :list)
+      Wire.put(w, "drop_if_rate_limited", drop_if_rate_limited, where, :bool)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "PushRateLimitStrategy")
+      d = Wire.obj(v, where)
+      new(
+        key: Wire.get(d, "key", where, :str),
+        policies: Wire.get(d, "policies", where, RateLimitPolicy, :list),
+        drop_if_rate_limited: Wire.get(d, "drop_if_rate_limited", where, :bool)
+      )
+    end
+  end
+
+  # RateLimitPolicy allows rate pushes per interval_ms. Centrifugo PRO only.
+  #
+  # @!attribute [r] rate
+  #   @return [Integer] The allowed number of pushes per interval. Required.
+  # @!attribute [r] interval_ms
+  #   @return [Integer] The interval in milliseconds. Required.
+  class RateLimitPolicy < Data.define(:rate, :interval_ms)
+    include Message
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "rate", rate, where, :int)
+      Wire.put(w, "interval_ms", interval_ms, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "RateLimitPolicy")
+      d = Wire.obj(v, where)
+      new(
+        rate: Wire.get(d, "rate", where, :int),
+        interval_ms: Wire.get(d, "interval_ms", where, :int)
+      )
+    end
+  end
+
+  # SendPushNotificationResult is the result of a send push notification
+  # call. Centrifugo PRO only.
+  #
+  # @!attribute [r] uid
+  #   @return [String] The unique identifier of the send request (not a provider
+  #     message ID). Matches the request uid if it was set.
+  class SendPushNotificationResult < Data.define(:uid)
+    include Message
+
+    def initialize(uid: "") = super
+
+    # The message as Centrifugo reads it, fields at their zero value left out.
+    #
+    # @api private
+    def to_wire(where = "")
+      w = {}
+      Wire.put(w, "uid", uid, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "SendPushNotificationResult")
+      d = Wire.obj(v, where)
+      new(
+        uid: Wire.get(d, "uid", where, :str)
+      )
+    end
+  end
+
+  # UpdatePushStatusResult is the result of an update push status call.
+  # Empty at the moment. Centrifugo PRO only.
+  class UpdatePushStatusResult < 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 = "UpdatePushStatusResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # CancelPushResult is the result of a cancel push call. Empty at the
+  # moment. Centrifugo PRO only.
+  class CancelPushResult < 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 = "CancelPushResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # MapPublishResult is the result of a map publish call.
+  #
+  # @!attribute [r] offset
+  #   @return [Integer] The offset in the channel stream.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the channel stream.
+  # @!attribute [r] suppressed
+  #   @return [Boolean] True if the publish was not applied, see
+  #     suppress_reason.
+  # @!attribute [r] suppress_reason
+  #   @return [String] Explains why the publish was suppressed, for example
+  #     "idempotency", "version", "key_exists" or "key_not_found".
+  class MapPublishResult < Data.define(:offset, :epoch, :suppressed, :suppress_reason)
+    include Message
+
+    def initialize(
+      offset: 0,
+      epoch: "",
+      suppressed: false,
+      suppress_reason: ""
+    )
+      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, "offset", offset, where, :int)
+      Wire.put(w, "epoch", epoch, where, :str)
+      Wire.put(w, "suppressed", suppressed, where, :bool)
+      Wire.put(w, "suppress_reason", suppress_reason, 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(
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str),
+        suppressed: Wire.get(d, "suppressed", where, :bool),
+        suppress_reason: Wire.get(d, "suppress_reason", where, :str)
+      )
+    end
+  end
+
+  # MapRemoveResult is the result of a map remove call.
+  #
+  # @!attribute [r] offset
+  #   @return [Integer] The offset in the channel stream.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the channel stream.
+  # @!attribute [r] suppressed
+  #   @return [Boolean] True if the removal was not applied, see
+  #     suppress_reason.
+  # @!attribute [r] suppress_reason
+  #   @return [String] Explains why the removal was suppressed, for example
+  #     "idempotency" or "key_not_found".
+  class MapRemoveResult < Data.define(:offset, :epoch, :suppressed, :suppress_reason)
+    include Message
+
+    def initialize(
+      offset: 0,
+      epoch: "",
+      suppressed: false,
+      suppress_reason: ""
+    )
+      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, "offset", offset, where, :int)
+      Wire.put(w, "epoch", epoch, where, :str)
+      Wire.put(w, "suppressed", suppressed, where, :bool)
+      Wire.put(w, "suppress_reason", suppress_reason, 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(
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str),
+        suppressed: Wire.get(d, "suppressed", where, :bool),
+        suppress_reason: Wire.get(d, "suppress_reason", where, :str)
+      )
+    end
+  end
+
+  # MapReadStateResult is the result of a map read state call.
+  #
+  # @!attribute [r] entries
+  #   @return [Array<MapEntry>] The state entries of this page.
+  # @!attribute [r] offset
+  #   @return [Integer] The offset of the channel stream position.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the channel stream position.
+  # @!attribute [r] cursor
+  #   @return [String] The cursor of the next page. Empty if there are no more
+  #     entries.
+  class MapReadStateResult < Data.define(:entries, :offset, :epoch, :cursor)
+    include Message
+
+    def initialize(
+      entries: [],
+      offset: 0,
+      epoch: "",
+      cursor: ""
+    )
+      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, "entries", entries, where, MapEntry, :list)
+      Wire.put(w, "offset", offset, where, :int)
+      Wire.put(w, "epoch", epoch, where, :str)
+      Wire.put(w, "cursor", cursor, where, :str)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "MapReadStateResult")
+      d = Wire.obj(v, where)
+      new(
+        entries: Wire.get(d, "entries", where, MapEntry, :list),
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str),
+        cursor: Wire.get(d, "cursor", where, :str)
+      )
+    end
+  end
+
+  # MapEntry is an entry of a map channel state or stream.
+  #
+  # @!attribute [r] key
+  #   @return [String] The entry key.
+  # @!attribute [r] data
+  #   @return [Object, nil] The entry data.
+  # @!attribute [r] tags
+  #   @return [Hash{String => String}] The entry tags.
+  # @!attribute [r] offset
+  #   @return [Integer] The offset of the entry in the channel stream.
+  # @!attribute [r] score
+  #   @return [Integer] The sort value of the entry in ordered map channels.
+  # @!attribute [r] removed
+  #   @return [Boolean] True for a removal event.
+  # @!attribute [r] time
+  #   @return [Integer] The time of the publication as Unix milliseconds, if known.
+  class MapEntry < Data.define(:key, :data, :tags, :offset, :score, :removed, :time)
+    include Message
+
+    def initialize(
+      key: "",
+      data: nil,
+      tags: {},
+      offset: 0,
+      score: 0,
+      removed: false,
+      time: 0
+    )
+      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, "tags", tags, where, :str, :map)
+      Wire.put(w, "offset", offset, where, :int)
+      Wire.put(w, "score", score, where, :int)
+      Wire.put(w, "removed", removed, where, :bool)
+      Wire.put(w, "time", time, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "MapEntry")
+      d = Wire.obj(v, where)
+      new(
+        key: Wire.get(d, "key", where, :str),
+        data: Wire.get(d, "data", where, :json),
+        tags: Wire.get(d, "tags", where, :str, :map),
+        offset: Wire.get(d, "offset", where, :int),
+        score: Wire.get(d, "score", where, :int),
+        removed: Wire.get(d, "removed", where, :bool),
+        time: Wire.get(d, "time", where, :int)
+      )
+    end
+  end
+
+  # MapReadStreamResult is the result of a map read stream call.
+  #
+  # @!attribute [r] entries
+  #   @return [Array<MapEntry>] The stream entries.
+  # @!attribute [r] offset
+  #   @return [Integer] The top offset of the channel stream.
+  # @!attribute [r] epoch
+  #   @return [String] The epoch of the channel stream.
+  class MapReadStreamResult < Data.define(:entries, :offset, :epoch)
+    include Message
+
+    def initialize(entries: [], offset: 0, 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, "entries", entries, where, MapEntry, :list)
+      Wire.put(w, "offset", offset, where, :int)
+      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 = "MapReadStreamResult")
+      d = Wire.obj(v, where)
+      new(
+        entries: Wire.get(d, "entries", where, MapEntry, :list),
+        offset: Wire.get(d, "offset", where, :int),
+        epoch: Wire.get(d, "epoch", where, :str)
+      )
+    end
+  end
+
+  # MapStatsResult is the result of a map stats call.
+  #
+  # @!attribute [r] num_keys
+  #   @return [Integer] The number of entries in the channel state.
+  class MapStatsResult < Data.define(:num_keys)
+    include Message
+
+    def initialize(num_keys: 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, "num_keys", num_keys, where, :int)
+      w
+    end
+
+    # The message from the Hash JSON.parse gives for it.
+    #
+    # @api private
+    def self.from_wire(v, where = "MapStatsResult")
+      d = Wire.obj(v, where)
+      new(
+        num_keys: Wire.get(d, "num_keys", where, :int)
+      )
+    end
+  end
+
+  # MapClearResult is the result of a map clear call. Empty at the moment.
+  class MapClearResult < 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 = "MapClearResult")
+      Wire.obj(v, where)
+      new
+    end
+  end
+
+  # SharedPollPublishResult is the result of a shared poll publish call.
+  # Empty at the moment.
+  class SharedPollPublishResult < 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 = "SharedPollPublishResult")
+      Wire.obj(v, where)
+      new
+    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 DeviceRegisterRequest.provider. The field is a String: a value
+  # Centrifugo sends or accepts which these do not name is still a valid one.
+
+  # The Provider "fcm".
+  PROVIDER_FCM = "fcm"
+
+  # The Provider "hms".
+  PROVIDER_HMS = "hms"
+
+  # The Provider "apns".
+  PROVIDER_APNS = "apns"
+
+  # The Provider "webpush".
+  PROVIDER_WEBPUSH = "webpush"
+
+  # The values of DeviceRegisterRequest.platform. The field is a String: a value
+  # Centrifugo sends or accepts which these do not name is still a valid one.
+
+  # The Platform "ios".
+  PLATFORM_IOS = "ios"
+
+  # The Platform "android".
+  PLATFORM_ANDROID = "android"
+
+  # The Platform "web".
+  PLATFORM_WEB = "web"
+
+  # The values of DeviceTopicsUpdate.op, DeviceTopicUpdateRequest.op and
+  # UserTopicUpdateRequest.op. The field is a String: a value Centrifugo sends
+  # or accepts which these do not name is still a valid one.
+
+  # The Op "add".
+  OP_ADD = "add"
+
+  # The Op "remove".
+  OP_REMOVE = "remove"
+
+  # The Op "set".
+  OP_SET = "set"
+
+  # The values of UpdatePushStatusRequest.status. The field is a String: a value
+  # Centrifugo sends or accepts which these do not name is still a valid one.
+
+  # The Status "delivered".
+  STATUS_DELIVERED = "delivered"
+
+  # The Status "interacted".
+  STATUS_INTERACTED = "interacted"
+
+  # The values of MapPublishRequest.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"
+end