cent 4.0.0 → 5.0.0

data/lib/cent/generated/methods.rb

@@ -0,0 +1,4226 @@
+# frozen_string_literal: true
+
+# Code generated by gen/generate.rb from proto/api.proto. DO NOT EDIT.
+
+module Cent
+  # Every API method, batch included, and whether only Centrifugo PRO has it.
+  #
+  # @api private
+  API_METHODS = {
+    "batch" => false,
+    "publish" => false,
+    "broadcast" => false,
+    "subscribe" => false,
+    "unsubscribe" => false,
+    "disconnect" => false,
+    "presence" => false,
+    "presence_stats" => false,
+    "history" => false,
+    "history_remove" => false,
+    "info" => false,
+    "refresh" => false,
+    "channels" => false,
+    "connections" => true,
+    "update_user_status" => true,
+    "get_user_status" => true,
+    "delete_user_status" => true,
+    "block_user" => true,
+    "unblock_user" => true,
+    "revoke_token" => true,
+    "invalidate_user_tokens" => true,
+    "device_register" => true,
+    "device_update" => true,
+    "device_remove" => true,
+    "device_list" => true,
+    "device_topic_list" => true,
+    "device_topic_update" => true,
+    "user_topic_list" => true,
+    "user_topic_update" => true,
+    "send_push_notification" => true,
+    "update_push_status" => true,
+    "cancel_push" => true,
+    "map_publish" => false,
+    "map_remove" => false,
+    "map_read_state" => false,
+    "map_read_stream" => false,
+    "map_stats" => false,
+    "map_clear" => false,
+    "shared_poll_publish" => false
+  }.freeze
+
+  # The fields each request - by its method - and each message in a request -
+  # by its name - must have a value in, and the messages in it to check:
+  # [field, required, the message's name or nil, a list]. Checked on the
+  # request's JSON, which leaves out a field at its zero value.
+  #
+  # @api private
+  REQUIRED = {
+    "publish" => [["channel", true, nil, false]].freeze,
+    "broadcast" => [["channels", true, nil, true]].freeze,
+    "subscribe" => [["channel", true, nil, false]].freeze,
+    "unsubscribe" => [["channel", true, nil, false]].freeze,
+    "disconnect" => [].freeze,
+    "presence" => [["channel", true, nil, false]].freeze,
+    "presence_stats" => [["channel", true, nil, false]].freeze,
+    "history" => [["channel", true, nil, false]].freeze,
+    "history_remove" => [["channel", true, nil, false]].freeze,
+    "info" => [].freeze,
+    "refresh" => [].freeze,
+    "channels" => [].freeze,
+    "connections" => [].freeze,
+    "update_user_status" => [["users", true, nil, true]].freeze,
+    "get_user_status" => [["users", true, nil, true]].freeze,
+    "delete_user_status" => [["users", true, nil, true]].freeze,
+    "block_user" => [["user", true, nil, false]].freeze,
+    "unblock_user" => [["user", true, nil, false]].freeze,
+    "revoke_token" => [["uid", true, nil, false]].freeze,
+    "invalidate_user_tokens" => [].freeze,
+    "device_register" => [
+      ["provider", true, nil, false],
+      ["token", true, nil, false],
+      ["platform", true, nil, false]
+    ].freeze,
+    "device_update" => [["topics_update", false, "DeviceTopicsUpdate", false]].freeze,
+    "device_remove" => [].freeze,
+    "device_list" => [].freeze,
+    "device_topic_list" => [].freeze,
+    "device_topic_update" => [["device_id", true, nil, false], ["op", true, nil, false]].freeze,
+    "user_topic_list" => [].freeze,
+    "user_topic_update" => [["op", true, nil, false]].freeze,
+    "send_push_notification" => [
+      ["recipient", true, nil, false],
+      ["notification", true, "PushNotification", false],
+      ["limit_strategy", false, "PushLimitStrategy", false]
+    ].freeze,
+    "update_push_status" => [
+      ["analytics_uid", true, nil, false],
+      ["status", true, nil, false],
+      ["device_id", true, nil, false]
+    ].freeze,
+    "cancel_push" => [["uid", true, nil, false]].freeze,
+    "map_publish" => [["channel", true, nil, false], ["key", true, nil, false]].freeze,
+    "map_remove" => [["channel", true, nil, false], ["key", true, nil, false]].freeze,
+    "map_read_state" => [["channel", true, nil, false]].freeze,
+    "map_read_stream" => [["channel", true, nil, false]].freeze,
+    "map_stats" => [["channel", true, nil, false]].freeze,
+    "map_clear" => [["channel", true, nil, false]].freeze,
+    "shared_poll_publish" => [
+      ["channel", true, nil, false],
+      ["key", true, nil, false],
+      ["version", true, nil, false]
+    ].freeze,
+    "DeviceTopicsUpdate" => [["op", true, nil, false]].freeze,
+    "PushNotification" => [
+      ["fcm", false, "FcmPushNotification", false],
+      ["hms", false, "HmsPushNotification", false],
+      ["apns", false, "ApnsPushNotification", false],
+      ["webpush", false, "WebPushPushNotification", false]
+    ].freeze,
+    "FcmPushNotification" => [["message", true, nil, false]].freeze,
+    "HmsPushNotification" => [["message", true, nil, false]].freeze,
+    "ApnsPushNotification" => [["payload", true, nil, false]].freeze,
+    "WebPushPushNotification" => [["payload", true, nil, false]].freeze,
+    "PushLimitStrategy" => [
+      ["rate_limit", false, "PushRateLimitStrategy", false],
+      ["time_limit", false, "PushTimeLimitStrategy", false]
+    ].freeze,
+    "PushRateLimitStrategy" => [["policies", false, "RateLimitPolicy", true]].freeze,
+    "RateLimitPolicy" => [["rate", true, nil, false], ["interval_ms", true, nil, false]].freeze,
+    "PushTimeLimitStrategy" => [
+      ["send_after_time", true, nil, false],
+      ["send_before_time", true, nil, false]
+    ].freeze
+  }.freeze
+
+  # The JSON of each API method's request, from its fields, as the methods of
+  # Client, Batch and Command take them.
+  #
+  # @api private
+  module Requests
+    module_function
+
+    def publish(
+      channel,
+      data,
+      b64data,
+      skip_history,
+      tags,
+      idempotency_key,
+      delta,
+      version,
+      version_epoch
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "data", data, "", :json)
+      Wire.put(w, "b64data", b64data, "", :str)
+      Wire.put(w, "skip_history", skip_history, "", :bool)
+      Wire.put(w, "tags", tags, "", :str, :map)
+      Wire.put(w, "idempotency_key", idempotency_key, "", :str)
+      Wire.put(w, "delta", delta, "", :bool)
+      Wire.put(w, "version", version, "", :int)
+      Wire.put(w, "version_epoch", version_epoch, "", :str)
+      w
+    end
+
+    def broadcast(
+      channels,
+      data,
+      b64data,
+      skip_history,
+      tags,
+      idempotency_key,
+      delta,
+      version,
+      version_epoch
+    )
+      w = {}
+      Wire.put(w, "channels", channels, "", :str, :list)
+      Wire.put(w, "data", data, "", :json)
+      Wire.put(w, "b64data", b64data, "", :str)
+      Wire.put(w, "skip_history", skip_history, "", :bool)
+      Wire.put(w, "tags", tags, "", :str, :map)
+      Wire.put(w, "idempotency_key", idempotency_key, "", :str)
+      Wire.put(w, "delta", delta, "", :bool)
+      Wire.put(w, "version", version, "", :int)
+      Wire.put(w, "version_epoch", version_epoch, "", :str)
+      w
+    end
+
+    def subscribe(
+      channel,
+      user,
+      expire_at,
+      info,
+      b64info,
+      client,
+      data,
+      b64data,
+      recover_since,
+      override,
+      session,
+      label_filter,
+      all_users
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "expire_at", expire_at, "", :int)
+      Wire.put(w, "info", info, "", :json)
+      Wire.put(w, "b64info", b64info, "", :str)
+      Wire.put(w, "client", client, "", :str)
+      Wire.put(w, "data", data, "", :json)
+      Wire.put(w, "b64data", b64data, "", :str)
+      Wire.put(w, "recover_since", recover_since, "", StreamPosition)
+      Wire.put(w, "override", override, "", SubscribeOptionOverride)
+      Wire.put(w, "session", session, "", :str)
+      Wire.put(w, "label_filter", label_filter, "", FilterNode)
+      Wire.put(w, "all_users", all_users, "", :bool)
+      w
+    end
+
+    def unsubscribe(
+      channel,
+      user,
+      client,
+      session,
+      label_filter,
+      all_users
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "client", client, "", :str)
+      Wire.put(w, "session", session, "", :str)
+      Wire.put(w, "label_filter", label_filter, "", FilterNode)
+      Wire.put(w, "all_users", all_users, "", :bool)
+      w
+    end
+
+    def disconnect(
+      user,
+      disconnect,
+      client,
+      whitelist,
+      session,
+      label_filter,
+      all_users
+    )
+      w = {}
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "disconnect", disconnect, "", Disconnect)
+      Wire.put(w, "client", client, "", :str)
+      Wire.put(w, "whitelist", whitelist, "", :str, :list)
+      Wire.put(w, "session", session, "", :str)
+      Wire.put(w, "label_filter", label_filter, "", FilterNode)
+      Wire.put(w, "all_users", all_users, "", :bool)
+      w
+    end
+
+    def presence(channel)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def presence_stats(channel)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def history(
+      channel,
+      limit,
+      since,
+      reverse
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      Wire.put(w, "since", since, "", StreamPosition)
+      Wire.put(w, "reverse", reverse, "", :bool)
+      w
+    end
+
+    def history_remove(channel)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def info
+      {}
+    end
+
+    def refresh(
+      user,
+      client,
+      expired,
+      expire_at,
+      info,
+      session,
+      label_filter,
+      all_users
+    )
+      w = {}
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "client", client, "", :str)
+      Wire.put(w, "expired", expired, "", :bool)
+      Wire.put(w, "expire_at", expire_at, "", :int)
+      Wire.put(w, "info", info, "", :json)
+      Wire.put(w, "session", session, "", :str)
+      Wire.put(w, "label_filter", label_filter, "", FilterNode)
+      Wire.put(w, "all_users", all_users, "", :bool)
+      w
+    end
+
+    def channels(pattern)
+      w = {}
+      Wire.put(w, "pattern", pattern, "", :str)
+      w
+    end
+
+    def connections(user, expression, label_filter)
+      w = {}
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "expression", expression, "", :str)
+      Wire.put(w, "label_filter", label_filter, "", FilterNode)
+      w
+    end
+
+    def update_user_status(users, state)
+      w = {}
+      Wire.put(w, "users", users, "", :str, :list)
+      Wire.put(w, "state", state, "", :str)
+      w
+    end
+
+    def get_user_status(users)
+      w = {}
+      Wire.put(w, "users", users, "", :str, :list)
+      w
+    end
+
+    def delete_user_status(users)
+      w = {}
+      Wire.put(w, "users", users, "", :str, :list)
+      w
+    end
+
+    def block_user(expire_at, user)
+      w = {}
+      Wire.put(w, "expire_at", expire_at, "", :int)
+      Wire.put(w, "user", user, "", :str)
+      w
+    end
+
+    def unblock_user(user)
+      w = {}
+      Wire.put(w, "user", user, "", :str)
+      w
+    end
+
+    def revoke_token(expire_at, uid)
+      w = {}
+      Wire.put(w, "expire_at", expire_at, "", :int)
+      Wire.put(w, "uid", uid, "", :str)
+      w
+    end
+
+    def invalidate_user_tokens(
+      expire_at,
+      user,
+      issued_before,
+      channel
+    )
+      w = {}
+      Wire.put(w, "expire_at", expire_at, "", :int)
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "issued_before", issued_before, "", :int)
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def device_register(
+      id,
+      provider,
+      token,
+      platform,
+      user,
+      meta,
+      topics,
+      timezone,
+      locale
+    )
+      w = {}
+      Wire.put(w, "id", id, "", :str)
+      Wire.put(w, "provider", provider, "", :str)
+      Wire.put(w, "token", token, "", :str)
+      Wire.put(w, "platform", platform, "", :str)
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "meta", meta, "", :str, :map)
+      Wire.put(w, "topics", topics, "", :str, :list)
+      Wire.put(w, "timezone", timezone, "", :str)
+      Wire.put(w, "locale", locale, "", :str)
+      w
+    end
+
+    def device_update(
+      ids,
+      users,
+      user_update,
+      meta_update,
+      topics_update,
+      timezone_update,
+      locale_update
+    )
+      w = {}
+      Wire.put(w, "ids", ids, "", :str, :list)
+      Wire.put(w, "users", users, "", :str, :list)
+      Wire.put(w, "user_update", user_update, "", DeviceUserUpdate, :presence)
+      Wire.put(w, "meta_update", meta_update, "", DeviceMetaUpdate, :presence)
+      Wire.put(w, "topics_update", topics_update, "", DeviceTopicsUpdate)
+      Wire.put(w, "timezone_update", timezone_update, "", DeviceTimezoneUpdate, :presence)
+      Wire.put(w, "locale_update", locale_update, "", DeviceLocaleUpdate, :presence)
+      w
+    end
+
+    def device_remove(ids, users)
+      w = {}
+      Wire.put(w, "ids", ids, "", :str, :list)
+      Wire.put(w, "users", users, "", :str, :list)
+      w
+    end
+
+    def device_list(
+      filter,
+      include_total_count,
+      include_meta,
+      include_topics,
+      include_webpush_keys,
+      cursor,
+      limit
+    )
+      w = {}
+      Wire.put(w, "filter", filter, "", DeviceFilter)
+      Wire.put(w, "include_total_count", include_total_count, "", :bool)
+      Wire.put(w, "include_meta", include_meta, "", :bool)
+      Wire.put(w, "include_topics", include_topics, "", :bool)
+      Wire.put(w, "include_webpush_keys", include_webpush_keys, "", :bool)
+      Wire.put(w, "cursor", cursor, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      w
+    end
+
+    def device_topic_list(
+      filter,
+      include_total_count,
+      include_device,
+      cursor,
+      limit
+    )
+      w = {}
+      Wire.put(w, "filter", filter, "", DeviceTopicFilter)
+      Wire.put(w, "include_total_count", include_total_count, "", :bool)
+      Wire.put(w, "include_device", include_device, "", :bool)
+      Wire.put(w, "cursor", cursor, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      w
+    end
+
+    def device_topic_update(
+      device_id,
+      op,
+      topics,
+      user
+    )
+      w = {}
+      Wire.put(w, "device_id", device_id, "", :str)
+      Wire.put(w, "op", op, "", :str)
+      Wire.put(w, "topics", topics, "", :str, :list)
+      Wire.put(w, "user", user, "", :str)
+      w
+    end
+
+    def user_topic_list(
+      filter,
+      include_total_count,
+      cursor,
+      limit
+    )
+      w = {}
+      Wire.put(w, "filter", filter, "", UserTopicFilter)
+      Wire.put(w, "include_total_count", include_total_count, "", :bool)
+      Wire.put(w, "cursor", cursor, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      w
+    end
+
+    def user_topic_update(user, op, topics)
+      w = {}
+      Wire.put(w, "user", user, "", :str)
+      Wire.put(w, "op", op, "", :str)
+      Wire.put(w, "topics", topics, "", :str, :list)
+      w
+    end
+
+    def send_push_notification(
+      recipient,
+      notification,
+      uid,
+      send_at,
+      optimize_for_reliability,
+      limit_strategy,
+      analytics_uid,
+      localizations,
+      use_templating,
+      use_meta
+    )
+      w = {}
+      Wire.put(w, "recipient", recipient, "", PushRecipient)
+      Wire.put(w, "notification", notification, "", PushNotification)
+      Wire.put(w, "uid", uid, "", :str)
+      Wire.put(w, "send_at", send_at, "", :int)
+      Wire.put(w, "optimize_for_reliability", optimize_for_reliability, "", :bool)
+      Wire.put(w, "limit_strategy", limit_strategy, "", PushLimitStrategy)
+      Wire.put(w, "analytics_uid", analytics_uid, "", :str)
+      Wire.put(w, "localizations", localizations, "", PushLocalization, :map)
+      Wire.put(w, "use_templating", use_templating, "", :bool)
+      Wire.put(w, "use_meta", use_meta, "", :bool)
+      w
+    end
+
+    def update_push_status(
+      analytics_uid,
+      status,
+      device_id,
+      msg_id
+    )
+      w = {}
+      Wire.put(w, "analytics_uid", analytics_uid, "", :str)
+      Wire.put(w, "status", status, "", :str)
+      Wire.put(w, "device_id", device_id, "", :str)
+      Wire.put(w, "msg_id", msg_id, "", :str)
+      w
+    end
+
+    def cancel_push(uid)
+      w = {}
+      Wire.put(w, "uid", uid, "", :str)
+      w
+    end
+
+    def map_publish(
+      channel,
+      key,
+      data,
+      b64data,
+      stream_data,
+      b64stream_data,
+      tags,
+      idempotency_key,
+      delta,
+      version,
+      version_epoch,
+      score,
+      key_mode
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "key", key, "", :str)
+      Wire.put(w, "data", data, "", :json)
+      Wire.put(w, "b64data", b64data, "", :str)
+      Wire.put(w, "stream_data", stream_data, "", :json)
+      Wire.put(w, "b64stream_data", b64stream_data, "", :str)
+      Wire.put(w, "tags", tags, "", :str, :map)
+      Wire.put(w, "idempotency_key", idempotency_key, "", :str)
+      Wire.put(w, "delta", delta, "", :bool)
+      Wire.put(w, "version", version, "", :int)
+      Wire.put(w, "version_epoch", version_epoch, "", :str)
+      Wire.put(w, "score", score, "", :int)
+      Wire.put(w, "key_mode", key_mode, "", :str)
+      w
+    end
+
+    def map_remove(channel, key, idempotency_key)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "key", key, "", :str)
+      Wire.put(w, "idempotency_key", idempotency_key, "", :str)
+      w
+    end
+
+    def map_read_state(
+      channel,
+      cursor,
+      limit,
+      key,
+      asc,
+      revision_offset,
+      revision_epoch
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "cursor", cursor, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      Wire.put(w, "key", key, "", :str)
+      Wire.put(w, "asc", asc, "", :bool)
+      Wire.put(w, "revision_offset", revision_offset, "", :int)
+      Wire.put(w, "revision_epoch", revision_epoch, "", :str)
+      w
+    end
+
+    def map_read_stream(
+      channel,
+      since_offset,
+      since_epoch,
+      limit,
+      reverse
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "since_offset", since_offset, "", :int)
+      Wire.put(w, "since_epoch", since_epoch, "", :str)
+      Wire.put(w, "limit", limit, "", :int)
+      Wire.put(w, "reverse", reverse, "", :bool)
+      w
+    end
+
+    def map_stats(channel)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def map_clear(channel)
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      w
+    end
+
+    def shared_poll_publish(
+      channel,
+      key,
+      data,
+      b64data,
+      version,
+      epoch
+    )
+      w = {}
+      Wire.put(w, "channel", channel, "", :str)
+      Wire.put(w, "key", key, "", :str)
+      Wire.put(w, "data", data, "", :json)
+      Wire.put(w, "b64data", b64data, "", :str)
+      Wire.put(w, "version", version, "", :int)
+      Wire.put(w, "epoch", epoch, "", :str)
+      w
+    end
+  end
+
+  # The server API methods of Client, one per method of api.proto.
+  #
+  # @api private
+  module ClientMethods
+    # Publishes data into a channel.
+    #
+    # @param channel [String, nil] The name of the channel to publish into. Required.
+    # @param data [Object, nil] The payload to publish. Required unless b64data is set. In the
+    #   HTTP API it is any JSON value; over GRPC it may be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding this publication to the channel history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to the
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not published
+    #   again, and the first one's result is returned. It acts per channel;
+    #   results are kept for 5 minutes by default. The memory, Redis and
+    #   PostgreSQL brokers keep keys; the NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publication to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [PublishResult]
+    # @raise [Error]
+    def publish(
+      channel:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      timeout: nil
+    )
+      invoke("publish", PublishResult, timeout) do
+        Requests.publish(
+          channel,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Publishes the same data into many channels.
+    #
+    # Channels succeed or fail on their own. It returns when every channel got the
+    # publication. When Centrifugo carried the broadcast out and one or more
+    # channels failed - up to all of them - it raises BroadcastFailedChannelsError,
+    # whose result holds every channel's outcome. Any other error means it failed
+    # as a whole: no channel got a reply. After a timeout or a network error
+    # Centrifugo may still have published it.
+    #
+    # To go on despite some failed channels:
+    #
+    #   begin
+    #     client.broadcast(channels:, data:)
+    #   rescue Cent::BroadcastFailedChannelsError => e
+    #     logger.warn("broadcast failed in #{e.result.failed.map(&:channel)}")
+    #   end
+    #
+    # Retry it with broadcast_with_retry, which sends again only the channels which
+    # may still succeed, with one idempotency_key.
+    #
+    # @param channels [Array<String>] The list of channels to publish into. Required.
+    # @param data [Object, nil] The payload to publish into each channel. Required unless
+    #   b64data is set. In the HTTP API it is any JSON value; over GRPC it may
+    #   be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding the publications to the channels' history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to each
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries. It acts per
+    #   channel: a broadcast retried with the same key is not published again
+    #   into the channels which already have it. Results are kept for 5 minutes
+    #   by default. The memory, Redis and PostgreSQL brokers keep keys; the
+    #   NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publications to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [BroadcastResult]
+    # @raise [Error]
+    def broadcast(
+      channels:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      timeout: nil
+    )
+      send_broadcast(timeout) do
+        Requests.broadcast(
+          channels,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Broadcasts as broadcast does, and retries the channels which failed for a
+    # temporary reason - see Cent.retryable? - up to max_attempts (2 by default:
+    # one retry).
+    #
+    # - Only the channels which may still succeed are sent again; when only
+    #   channels which failed for good are left, it stops.
+    # - Every attempt carries the same idempotency_key - made for the call when
+    #   none is given - so that a channel which got the publication in an earlier
+    #   attempt does not get it again. The memory, Redis and PostgreSQL brokers
+    #   keep keys; the NATS broker ignores them, and a retry may publish again.
+    # - The result holds every channel's last outcome, and the key: retrying later
+    #   with it publishes only into the channels which did not get it.
+    #
+    # timeout, when set, bounds the whole call, waits included. attempt_timeout is
+    # each attempt's own timeout, replacing request_timeout - longer or shorter -
+    # as a call's timeout does; timeout still ends an attempt sooner.
+    #
+    # The block, when given, is called after an attempt which failed in a way a
+    # retry may fix, except the last, with a BroadcastAttempt. It returns the
+    # seconds to wait before the next attempt, or nil for the default wait -
+    # Cent.exponential_backoff(0.1, 5.0) of the attempt - and may log or count
+    # meanwhile. To stop, it raises: its exception propagates, its cause the
+    # attempt's error. The wait never outlasts the call's timeout.
+    #
+    #   client.broadcast_with_retry(channels:, data:, max_attempts: 5) do |attempt|
+    #     logger.info("attempt #{attempt.attempt}: #{attempt.retry.size} channels to retry")
+    #     nil
+    #   end
+    #
+    # It raises as broadcast does.
+    #
+    # @param channels [Array<String>] The list of channels to publish into. Required.
+    # @param data [Object, nil] The payload to publish into each channel. Required unless
+    #   b64data is set. In the HTTP API it is any JSON value; over GRPC it may
+    #   be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding the publications to the channels' history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to each
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries. It acts per
+    #   channel: a broadcast retried with the same key is not published again
+    #   into the channels which already have it. Results are kept for 5 minutes
+    #   by default. The memory, Redis and PostgreSQL brokers keep keys; the
+    #   NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publications to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @param max_attempts [Integer] Attempts at most, the first included.
+    # @param attempt_timeout [Numeric, nil] Seconds bounding each attempt, replacing request_timeout:
+    #   request_timeout when nil.
+    # @param timeout [Numeric, nil] Seconds bounding the whole call, waits included: no
+    #   bound but each attempt's when nil.
+    # @yieldparam attempt [BroadcastAttempt] a failed attempt which will be retried
+    # @yieldreturn [Numeric, nil] seconds to wait before the next attempt, nil for the default
+    # @return [BroadcastResult]
+    # @raise [Error]
+    def broadcast_with_retry(
+      channels:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      max_attempts: 2,
+      attempt_timeout: nil,
+      timeout: nil,
+      &on_attempt_error
+    )
+      retry_broadcast(max_attempts, attempt_timeout, timeout, on_attempt_error) do
+        Requests.broadcast(
+          channels,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Subscribes active sessions of a user to a channel
+    # (server-side subscription). It does not create a streaming subscription
+    # for the caller.
+    #
+    # @param channel [String, nil] The name of the channel to subscribe to. Required.
+    # @param user [String, nil] The ID of the user to subscribe. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the subscription expires.
+    # @param info [Object, nil] Custom channel info attached to the subscription, used in
+    #   presence and join/leave messages.
+    # @param b64info [String, nil] Info as base64, for binary. Centrifugo decodes it.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param data [Object, nil] Custom subscription data sent to the client in the Subscribe
+    #   push.
+    # @param b64data [String, nil] Data as base64, for binary. Centrifugo decodes it.
+    # @param recover_since [StreamPosition, Hash, nil] The stream position to recover publications from.
+    # @param override [SubscribeOptionOverride, Hash, nil] Dynamically overrides some channel options set in the
+    #   Centrifugo configuration.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] When user is empty, targets every connection on every node
+    #   instead of the anonymous-only bucket. No effect when user is non-empty.
+    #   Without label_filter it acts on every connection. Centrifugo PRO only.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [SubscribeResult]
+    # @raise [Error]
+    def subscribe(
+      channel:,
+      user: nil,
+      expire_at: nil,
+      info: nil,
+      b64info: nil,
+      client: nil,
+      data: nil,
+      b64data: nil,
+      recover_since: nil,
+      override: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil,
+      timeout: nil
+    )
+      invoke("subscribe", SubscribeResult, timeout) do
+        Requests.subscribe(
+          channel,
+          user,
+          expire_at,
+          info,
+          b64info,
+          client,
+          data,
+          b64data,
+          recover_since,
+          override,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Unsubscribes a user from a channel.
+    #
+    # @param channel [String, nil] The name of the channel to unsubscribe from. Required.
+    # @param user [String, nil] The ID of the user to unsubscribe. Required, unless all_users
+    #   is used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UnsubscribeResult]
+    # @raise [Error]
+    def unsubscribe(
+      channel:,
+      user: nil,
+      client: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil,
+      timeout: nil
+    )
+      invoke("unsubscribe", UnsubscribeResult, timeout) do
+        Requests.unsubscribe(
+          channel,
+          user,
+          client,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Disconnects a user's connections.
+    #
+    # @param user [String, nil] The ID of the user to disconnect. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param disconnect [Disconnect, Hash, nil] A custom disconnect code and reason. If not set, clients
+    #   are disconnected with a force no-reconnect disconnect.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param whitelist [Array<String>] A list of client IDs to keep connected.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DisconnectResult]
+    # @raise [Error]
+    def disconnect(
+      user: nil,
+      disconnect: nil,
+      client: nil,
+      whitelist: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil,
+      timeout: nil
+    )
+      invoke("disconnect", DisconnectResult, timeout) do
+        Requests.disconnect(
+          user,
+          disconnect,
+          client,
+          whitelist,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns the online presence of a channel: all clients
+    # currently subscribed to it. Presence must be enabled for the channel.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [PresenceResult]
+    # @raise [Error]
+    def presence(channel:, timeout: nil)
+      invoke("presence", PresenceResult, timeout) do
+        Requests.presence(channel)
+      end
+    end
+
+    # Returns short presence information of a channel: the
+    # number of clients and of unique users. Presence must be enabled for the
+    # channel.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [PresenceStatsResult]
+    # @raise [Error]
+    def presence_stats(channel:, timeout: nil)
+      invoke("presence_stats", PresenceStatsResult, timeout) do
+        Requests.presence_stats(channel)
+      end
+    end
+
+    # Returns publications from the history of a channel.
+    # History must be enabled for the channel.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param limit [Integer, nil] The maximum number of publications to return; -1 returns all
+    #   the channel keeps. If not set, only the current stream position is
+    #   returned, without publications.
+    # @param since [StreamPosition, Hash, nil] Returns publications after this stream position.
+    # @param reverse [Boolean, nil] Iterates in reverse order, from latest to earliest.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [HistoryResult]
+    # @raise [Error]
+    def history(
+      channel:,
+      limit: nil,
+      since: nil,
+      reverse: nil,
+      timeout: nil
+    )
+      invoke("history", HistoryResult, timeout) do
+        Requests.history(channel, limit, since, reverse)
+      end
+    end
+
+    # Every publication of a channel's history, oldest first, a page of limit
+    # at a time: from since when it is set, from the start of what the channel
+    # keeps otherwise. limit is the page size, so it must be 1 or more, and
+    # reverse is refused, before anything is sent: since reads forward only.
+    # The iteration ends after a page shorter than limit. A publication made
+    # while iterating may or may not be seen. An epoch which changed since a
+    # page was read - the history was lost, with a Redis restart say - raises
+    # UnrecoverablePositionError: reading again from the start is the only way
+    # on. Each publication comes with its position, as a HistoryItem.
+    #
+    # Returns an Enumerator, or with a block, yields each item and returns nil. A
+    # page is read when the iteration reaches it, and leaving the iteration early
+    # reads no further page. An error raises from the iteration, after the items
+    # before it. The iteration lasts as long as the caller's loop: page_timeout
+    # bounds each page's request, as attempt_timeout bounds a retry's attempt.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param limit [Integer, nil] The maximum number of publications to return; -1 returns all
+    #   the channel keeps. If not set, only the current stream position is
+    #   returned, without publications.
+    # @param since [StreamPosition, Hash, nil] Returns publications after this stream position.
+    # @param reverse [Boolean, nil] Iterates in reverse order, from latest to earliest.
+    # @param page_timeout [Numeric, nil] Seconds bounding each page's request, replacing
+    #   request_timeout for it, longer or shorter: request_timeout when nil. Zero is refused.
+    # @yieldparam item [HistoryItem]
+    # @return [Enumerator<HistoryItem>, nil]
+    # @raise [Error]
+    def history_all(
+      channel:,
+      limit: nil,
+      since: nil,
+      reverse: nil,
+      page_timeout: nil,
+      &block
+    )
+      pages("history", page_timeout, block) do
+        Requests.history(channel, limit, since, reverse)
+      end
+    end
+
+    # Removes publications from the history of a channel.
+    # The current top stream position is kept, so clients do not get
+    # disconnected because of insufficient state.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [HistoryRemoveResult]
+    # @raise [Error]
+    def history_remove(channel:, timeout: nil)
+      invoke("history_remove", HistoryRemoveResult, timeout) do
+        Requests.history_remove(channel)
+      end
+    end
+
+    # Returns information about the running Centrifugo nodes.
+    #
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [InfoResult]
+    # @raise [Error]
+    def info(timeout: nil)
+      invoke("info", InfoResult, timeout) do
+        Requests.info
+      end
+    end
+
+    # Refreshes a user's connections, mostly useful with
+    # unidirectional transports. Without expire_at the connections become
+    # non-expiring.
+    #
+    # @param user [String, nil] The ID of the user to refresh. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param expired [Boolean, nil] Marks the connections as expired and closes them with an
+    #   expired disconnect reason.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the connections expire.
+    # @param info [Object, nil] Attaches or replaces the connection info.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [RefreshResult]
+    # @raise [Error]
+    def refresh(
+      user: nil,
+      client: nil,
+      expired: nil,
+      expire_at: nil,
+      info: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil,
+      timeout: nil
+    )
+      invoke("refresh", RefreshResult, timeout) do
+        Requests.refresh(
+          user,
+          client,
+          expired,
+          expire_at,
+          info,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns active channels (with one or more subscribers).
+    # It can be heavy on large deployments: there is no pagination.
+    #
+    # @param pattern [String, nil] Filters channels by name, using gobwas/glob syntax.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [ChannelsResult]
+    # @raise [Error]
+    def channels(pattern: nil, timeout: nil)
+      invoke("channels", ChannelsResult, timeout) do
+        Requests.channels(pattern)
+      end
+    end
+
+    # Returns information about active connections, without
+    # the need to enable presence. At least one of user, expression or
+    # label_filter must be set. Centrifugo PRO only.
+    #
+    # @param user [String, nil] Returns only the connections of this user ID.
+    # @param expression [String, nil] A CEL expression to filter connections.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the listing to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [ConnectionsResult]
+    # @raise [Error]
+    def connections(
+      user: nil,
+      expression: nil,
+      label_filter: nil,
+      timeout: nil
+    )
+      invoke("connections", ConnectionsResult, timeout) do
+        Requests.connections(user, expression, label_filter)
+      end
+    end
+
+    # Marks users as active and online now, and sets
+    # their state when one is given. Centrifugo PRO only.
+    #
+    # @param users [Array<String>] The list of user IDs to update the status for. Required.
+    # @param state [String, nil] An optional custom state to store in the user status. It can
+    #   be restricted by the user_status.state_regex option.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UpdateUserStatusResult]
+    # @raise [Error]
+    def update_user_status(users:, state: nil, timeout: nil)
+      invoke("update_user_status", UpdateUserStatusResult, timeout) do
+        Requests.update_user_status(users, state)
+      end
+    end
+
+    # Returns the status of users. Centrifugo PRO only.
+    #
+    # @param users [Array<String>] The list of user IDs to get the status for. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [GetUserStatusResult]
+    # @raise [Error]
+    def get_user_status(users:, timeout: nil)
+      invoke("get_user_status", GetUserStatusResult, timeout) do
+        Requests.get_user_status(users)
+      end
+    end
+
+    # Deletes the status of users. Centrifugo PRO only.
+    #
+    # @param users [Array<String>] The list of user IDs to delete the status for. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeleteUserStatusResult]
+    # @raise [Error]
+    def delete_user_status(users:, timeout: nil)
+      invoke("delete_user_status", DeleteUserStatusResult, timeout) do
+        Requests.delete_user_status(users)
+      end
+    end
+
+    # Blocks a user: the user is disconnected and can not
+    # connect again until unblocked or the block expires. Centrifugo PRO only.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the block expires. Optional,
+    #   but a reasonably small value is recommended to keep the set of blocked
+    #   users small.
+    # @param user [String, nil] The ID of the user to block. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [BlockUserResult]
+    # @raise [Error]
+    def block_user(user:, expire_at: nil, timeout: nil)
+      invoke("block_user", BlockUserResult, timeout) do
+        Requests.block_user(expire_at, user)
+      end
+    end
+
+    # Unblocks a user. Centrifugo PRO only.
+    #
+    # @param user [String, nil] The ID of the user to unblock. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UnblockUserResult]
+    # @raise [Error]
+    def unblock_user(user:, timeout: nil)
+      invoke("unblock_user", UnblockUserResult, timeout) do
+        Requests.unblock_user(user)
+      end
+    end
+
+    # Revokes a token by its unique ID (jti claim of a JWT).
+    # Clients using the token are disconnected shortly, and can not connect
+    # with it again. Centrifugo PRO only.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the revocation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param uid [String, nil] The unique ID of the token to revoke (jti claim). Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [RevokeTokenResult]
+    # @raise [Error]
+    def revoke_token(uid:, expire_at: nil, timeout: nil)
+      invoke("revoke_token", RevokeTokenResult, timeout) do
+        Requests.revoke_token(expire_at, uid)
+      end
+    end
+
+    # Revokes all tokens of a user issued before a
+    # certain time (based on the iat claim of a JWT). Centrifugo PRO only.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the invalidation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param user [String, nil] The ID of the user whose tokens to invalidate. Required. ""
+    #   invalidates the tokens of anonymous users.
+    # @param issued_before [Integer, nil] The Unix time in seconds: tokens issued before it are
+    #   considered revoked. If not set, the current time is used.
+    # @param channel [String, nil] Limits the invalidation to subscription tokens for this
+    #   channel.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [InvalidateUserTokensResult]
+    # @raise [Error]
+    def invalidate_user_tokens(
+      user:,
+      expire_at: nil,
+      issued_before: nil,
+      channel: nil,
+      timeout: nil
+    )
+      invoke("invalidate_user_tokens", InvalidateUserTokensResult, timeout) do
+        Requests.invalidate_user_tokens(expire_at, user, issued_before, channel)
+      end
+    end
+
+    # Registers a device for push notifications, or
+    # updates a registered one. Centrifugo PRO only.
+    #
+    # @param id [String, nil] The device ID. Omit it on first registration: Centrifugo
+    #   generates one and returns it. Pass the stored value to update the
+    #   device.
+    # @param provider [String, nil] The provider of the device token. Required. One of: fcm,
+    #   hms, apns, webpush.
+    # @param token [String, nil] The push token of the device. For webpush, it is the browser
+    #   PushSubscription serialized as a JSON string. Required.
+    # @param platform [String, nil] The device platform. Required. One of: ios, android, web.
+    # @param user [String, nil] The user associated with the device.
+    # @param meta [Hash{String => String}] Additional custom metadata of the device.
+    # @param topics [Array<String>] The full list of the device's topic subscriptions, replacing
+    #   the previous one. The user's topics are attached automatically.
+    # @param timezone [String, nil] The IANA time zone of the device user, for example
+    #   Europe/Nicosia.
+    # @param locale [String, nil] The locale of the device user as an IETF BCP 47 language
+    #   tag, for example en-US.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceRegisterResult]
+    # @raise [Error]
+    def device_register(
+      provider:,
+      token:,
+      platform:,
+      id: nil,
+      user: nil,
+      meta: nil,
+      topics: nil,
+      timezone: nil,
+      locale: nil,
+      timeout: nil
+    )
+      invoke("device_register", DeviceRegisterResult, timeout) do
+        Requests.device_register(
+          id,
+          provider,
+          token,
+          platform,
+          user,
+          meta,
+          topics,
+          timezone,
+          locale
+        )
+      end
+    end
+
+    # Updates registered devices, selected by ids and/or
+    # users. Centrifugo PRO only.
+    #
+    # @param ids [Array<String>] Selects devices by ID.
+    # @param users [Array<String>] Selects devices by user.
+    # @param user_update [DeviceUserUpdate, Hash, nil] Changes the user ID of the devices. It does not re-sync
+    #   user-bound topics; use DeviceRegisterRequest to assign a device to
+    #   another user.
+    # @param meta_update [DeviceMetaUpdate, Hash, nil] Updates the device meta.
+    # @param topics_update [DeviceTopicsUpdate, Hash, nil] Updates the device topics.
+    # @param timezone_update [DeviceTimezoneUpdate, Hash, nil] Updates the device timezone.
+    # @param locale_update [DeviceLocaleUpdate, Hash, nil] Updates the device locale.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceUpdateResult]
+    # @raise [Error]
+    def device_update(
+      ids: nil,
+      users: nil,
+      user_update: nil,
+      meta_update: nil,
+      topics_update: nil,
+      timezone_update: nil,
+      locale_update: nil,
+      timeout: nil
+    )
+      invoke("device_update", DeviceUpdateResult, timeout) do
+        Requests.device_update(
+          ids,
+          users,
+          user_update,
+          meta_update,
+          topics_update,
+          timezone_update,
+          locale_update
+        )
+      end
+    end
+
+    # Removes devices, selected by ids and/or users.
+    # Centrifugo PRO only.
+    #
+    # @param ids [Array<String>] Selects devices to remove by ID.
+    # @param users [Array<String>] Selects devices to remove by user.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceRemoveResult]
+    # @raise [Error]
+    def device_remove(ids: nil, users: nil, timeout: nil)
+      invoke("device_remove", DeviceRemoveResult, timeout) do
+        Requests.device_remove(ids, users)
+      end
+    end
+
+    # Returns a paginated list of registered devices.
+    # Centrifugo PRO only.
+    #
+    # @param filter [DeviceFilter, Hash, nil] Selects the devices to list: all of them when unset.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_meta [Boolean, nil] Includes meta of each device.
+    # @param include_topics [Boolean, nil] Includes topics of each device.
+    # @param include_webpush_keys [Boolean, nil] Includes webpush_keys of each device (webpush
+    #   only).
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of devices to return.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceListResult]
+    # @raise [Error]
+    def device_list(
+      filter: nil,
+      include_total_count: nil,
+      include_meta: nil,
+      include_topics: nil,
+      include_webpush_keys: nil,
+      cursor: nil,
+      limit: nil,
+      timeout: nil
+    )
+      invoke("device_list", DeviceListResult, timeout) do
+        Requests.device_list(
+          filter,
+          include_total_count,
+          include_meta,
+          include_topics,
+          include_webpush_keys,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Every device the request selects, a page at a time: limit is the page
+    # size, the server's default when unset. A device registered or removed
+    # while iterating may or may not be seen.
+    #
+    # Returns an Enumerator, or with a block, yields each item and returns nil. A
+    # page is read when the iteration reaches it, and leaving the iteration early
+    # reads no further page. An error raises from the iteration, after the items
+    # before it. The iteration lasts as long as the caller's loop: page_timeout
+    # bounds each page's request, as attempt_timeout bounds a retry's attempt.
+    #
+    # Centrifugo PRO only.
+    #
+    # @param filter [DeviceFilter, Hash, nil] Selects the devices to list: all of them when unset.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_meta [Boolean, nil] Includes meta of each device.
+    # @param include_topics [Boolean, nil] Includes topics of each device.
+    # @param include_webpush_keys [Boolean, nil] Includes webpush_keys of each device (webpush
+    #   only).
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of devices to return.
+    # @param page_timeout [Numeric, nil] Seconds bounding each page's request, replacing
+    #   request_timeout for it, longer or shorter: request_timeout when nil. Zero is refused.
+    # @yieldparam item [Device]
+    # @return [Enumerator<Device>, nil]
+    # @raise [Error]
+    def device_list_all(
+      filter: nil,
+      include_total_count: nil,
+      include_meta: nil,
+      include_topics: nil,
+      include_webpush_keys: nil,
+      cursor: nil,
+      limit: nil,
+      page_timeout: nil,
+      &block
+    )
+      pages("device_list", page_timeout, block) do
+        Requests.device_list(
+          filter,
+          include_total_count,
+          include_meta,
+          include_topics,
+          include_webpush_keys,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Returns a paginated list of device topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # @param filter [DeviceTopicFilter, Hash, nil] Selects the device topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_device [Boolean, nil] Includes the Device of each item.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceTopicListResult]
+    # @raise [Error]
+    def device_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      include_device: nil,
+      cursor: nil,
+      limit: nil,
+      timeout: nil
+    )
+      invoke("device_topic_list", DeviceTopicListResult, timeout) do
+        Requests.device_topic_list(
+          filter,
+          include_total_count,
+          include_device,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Every device topic the request selects, a page at a time, as
+    # device_list_all reads devices.
+    #
+    # Returns an Enumerator, or with a block, yields each item and returns nil. A
+    # page is read when the iteration reaches it, and leaving the iteration early
+    # reads no further page. An error raises from the iteration, after the items
+    # before it. The iteration lasts as long as the caller's loop: page_timeout
+    # bounds each page's request, as attempt_timeout bounds a retry's attempt.
+    #
+    # Centrifugo PRO only.
+    #
+    # @param filter [DeviceTopicFilter, Hash, nil] Selects the device topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_device [Boolean, nil] Includes the Device of each item.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @param page_timeout [Numeric, nil] Seconds bounding each page's request, replacing
+    #   request_timeout for it, longer or shorter: request_timeout when nil. Zero is refused.
+    # @yieldparam item [DeviceTopic]
+    # @return [Enumerator<DeviceTopic>, nil]
+    # @raise [Error]
+    def device_topic_list_all(
+      filter: nil,
+      include_total_count: nil,
+      include_device: nil,
+      cursor: nil,
+      limit: nil,
+      page_timeout: nil,
+      &block
+    )
+      pages("device_topic_list", page_timeout, block) do
+        Requests.device_topic_list(
+          filter,
+          include_total_count,
+          include_device,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Changes the topics of a device. The device topic
+    # list is what decides who gets a push sent to a topic.
+    # Centrifugo PRO only.
+    #
+    # @param device_id [String, nil] The ID of the device. Required.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @param user [String, nil] An optional ownership guard: the update is applied only if the
+    #   device currently belongs to this user. Otherwise the call fails with a
+    #   conflict error (or not found if there is no such device).
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [DeviceTopicUpdateResult]
+    # @raise [Error]
+    def device_topic_update(
+      device_id:,
+      op:,
+      topics: nil,
+      user: nil,
+      timeout: nil
+    )
+      invoke("device_topic_update", DeviceTopicUpdateResult, timeout) do
+        Requests.device_topic_update(device_id, op, topics, user)
+      end
+    end
+
+    # Returns a paginated list of user topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # @param filter [UserTopicFilter, Hash, nil] Selects the user topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UserTopicListResult]
+    # @raise [Error]
+    def user_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      cursor: nil,
+      limit: nil,
+      timeout: nil
+    )
+      invoke("user_topic_list", UserTopicListResult, timeout) do
+        Requests.user_topic_list(filter, include_total_count, cursor, limit)
+      end
+    end
+
+    # Every user topic the request selects, a page at a time, as
+    # device_list_all reads devices.
+    #
+    # Returns an Enumerator, or with a block, yields each item and returns nil. A
+    # page is read when the iteration reaches it, and leaving the iteration early
+    # reads no further page. An error raises from the iteration, after the items
+    # before it. The iteration lasts as long as the caller's loop: page_timeout
+    # bounds each page's request, as attempt_timeout bounds a retry's attempt.
+    #
+    # Centrifugo PRO only.
+    #
+    # @param filter [UserTopicFilter, Hash, nil] Selects the user topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @param page_timeout [Numeric, nil] Seconds bounding each page's request, replacing
+    #   request_timeout for it, longer or shorter: request_timeout when nil. Zero is refused.
+    # @yieldparam item [UserTopic]
+    # @return [Enumerator<UserTopic>, nil]
+    # @raise [Error]
+    def user_topic_list_all(
+      filter: nil,
+      include_total_count: nil,
+      cursor: nil,
+      limit: nil,
+      page_timeout: nil,
+      &block
+    )
+      pages("user_topic_list", page_timeout, block) do
+        Requests.user_topic_list(filter, include_total_count, cursor, limit)
+      end
+    end
+
+    # Changes the topics of a user. The change is also
+    # applied to the user's registered devices. Centrifugo PRO only.
+    #
+    # @param user [String, nil] The user ID. Required. "" updates the global binding, which every
+    #   device - anonymous ones included - gets on its next device_register.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UserTopicUpdateResult]
+    # @raise [Error]
+    def user_topic_update(
+      user:,
+      op:,
+      topics: nil,
+      timeout: nil
+    )
+      invoke("user_topic_update", UserTopicUpdateResult, timeout) do
+        Requests.user_topic_update(user, op, topics)
+      end
+    end
+
+    # Sends a push notification. The request is
+    # queued and sent to the provider by Centrifugo workers.
+    # Centrifugo PRO only.
+    #
+    # @param recipient [PushRecipient, Hash, nil] Who receives the notification. Required.
+    # @param notification [PushNotification, Hash, nil] The notification to send. Required.
+    # @param uid [String, nil] A unique identifier of the request, can be used to cancel the
+    #   push. UUID v4 is recommended; different requests must use different
+    #   uids.
+    # @param send_at [Integer, nil] The Unix time in seconds when to send the notification. If
+    #   not set, the notification is sent immediately.
+    # @param optimize_for_reliability [Boolean, nil] Makes processing heavier, but tolerates edge
+    #   cases, like not losing inflight pushes when the queue is briefly
+    #   unavailable.
+    # @param limit_strategy [PushLimitStrategy, Hash, nil] Sets time constraints and rate limits. Only applies
+    #   with a filter recipient; devices are then processed one by one
+    #   instead of in batches. Needs notification.expire_at: a push the limits
+    #   hold back is not tried forever.
+    # @param analytics_uid [String, nil] The identifier for push notification analytics. If
+    #   not set, uid is used.
+    # @param localizations [Hash{String => PushLocalization, Hash}] Optional per language/locale localizations. Setting
+    #   them enables templating.
+    # @param use_templating [Boolean, nil] Enables templating of the notification. Only works
+    #   with a filter recipient.
+    # @param use_meta [Boolean, nil] Additionally loads device meta while sending, making it
+    #   available in templating.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [SendPushNotificationResult]
+    # @raise [Error]
+    def send_push_notification(
+      recipient:,
+      notification:,
+      uid: nil,
+      send_at: nil,
+      optimize_for_reliability: nil,
+      limit_strategy: nil,
+      analytics_uid: nil,
+      localizations: nil,
+      use_templating: nil,
+      use_meta: nil,
+      timeout: nil
+    )
+      invoke("send_push_notification", SendPushNotificationResult, timeout) do
+        Requests.send_push_notification(
+          recipient,
+          notification,
+          uid,
+          send_at,
+          optimize_for_reliability,
+          limit_strategy,
+          analytics_uid,
+          localizations,
+          use_templating,
+          use_meta
+        )
+      end
+    end
+
+    # Saves the delivery or interaction status of a
+    # push notification to analytics. Experimental. Centrifugo PRO only.
+    #
+    # @param analytics_uid [String, nil] The analytics_uid of the push notification (as in
+    #   SendPushNotificationRequest). Required.
+    # @param status [String, nil] The status of the push notification. Required. One of:
+    #   delivered, interacted.
+    # @param device_id [String, nil] The Centrifugo device ID. Required.
+    # @param msg_id [String, nil] The message ID issued by the provider.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [UpdatePushStatusResult]
+    # @raise [Error]
+    def update_push_status(
+      analytics_uid:,
+      status:,
+      device_id:,
+      msg_id: nil,
+      timeout: nil
+    )
+      invoke("update_push_status", UpdatePushStatusResult, timeout) do
+        Requests.update_push_status(analytics_uid, status, device_id, msg_id)
+      end
+    end
+
+    # Cancels a delayed push notification (sent with
+    # send_at). Centrifugo PRO only.
+    #
+    # @param uid [String, nil] The uid of the push notification to cancel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [CancelPushResult]
+    # @raise [Error]
+    def cancel_push(uid:, timeout: nil)
+      invoke("cancel_push", CancelPushResult, timeout) do
+        Requests.cancel_push(uid)
+      end
+    end
+
+    # Publishes or updates a key in a map channel.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The entry key. Required.
+    # @param data [Object, nil] The entry data. In the HTTP API it is any JSON value; over GRPC
+    #   it may be binary.
+    # @param b64data [String, nil] Data as base64, for binary over the HTTP API. Centrifugo
+    #   decodes it.
+    # @param stream_data [Object, nil] Currently not used by the server API.
+    # @param b64stream_data [String, nil] Currently not used by the server API.
+    # @param tags [Hash{String => String}] Key-value metadata attached to the publication.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not applied
+    #   again, and its result has the first one's position, with suppressed
+    #   set and suppress_reason "idempotency". It acts per channel; keys are
+    #   kept for 5 minutes by default. Every map broker - memory, Redis and
+    #   PostgreSQL - keeps keys.
+    # @param delta [Boolean, nil] Enables delta compression for this publication.
+    # @param version [Integer, nil] A per-key version: publications with a version not higher
+    #   than the key's current one are suppressed.
+    # @param version_epoch [String, nil] Scopes version. A different epoch resets version
+    #   comparison.
+    # @param score [Integer, nil] Currently not used by the server API.
+    # @param key_mode [String, nil] Makes the publish conditional: if_new writes only if the key
+    #   does not exist, if_exists only if it exists. Empty always writes.
+    #   One of: if_new, if_exists.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapPublishResult]
+    # @raise [Error]
+    def map_publish(
+      channel:,
+      key:,
+      data: nil,
+      b64data: nil,
+      stream_data: nil,
+      b64stream_data: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      score: nil,
+      key_mode: nil,
+      timeout: nil
+    )
+      invoke("map_publish", MapPublishResult, timeout) do
+        Requests.map_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          stream_data,
+          b64stream_data,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch,
+          score,
+          key_mode
+        )
+      end
+    end
+
+    # Removes a key from a map channel.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The key to remove. Required.
+    # @param idempotency_key [String, nil] Drops duplicate removals upon retries, as it does for
+    #   MapPublishRequest: a removal with a key already used in the channel is
+    #   not applied again, and its result is suppressed with suppress_reason
+    #   "idempotency". Keys are kept for 5 minutes by default.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapRemoveResult]
+    # @raise [Error]
+    def map_remove(
+      channel:,
+      key:,
+      idempotency_key: nil,
+      timeout: nil
+    )
+      invoke("map_remove", MapRemoveResult, timeout) do
+        Requests.map_remove(channel, key, idempotency_key)
+      end
+    end
+
+    # Reads the current state of a map channel, with
+    # optional pagination.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param cursor [String, nil] The pagination cursor from the previous page. Empty starts
+    #   from the beginning.
+    # @param limit [Integer, nil] The maximum number of entries per page: -1 means no limit, 0
+    #   returns only the stream position. Page sizes may exceed it with the
+    #   Redis map broker.
+    # @param key [String, nil] Reads a single entry by exact key. cursor and limit are ignored
+    #   when it is set.
+    # @param asc [Boolean, nil] Sorts ordered state by score ascending instead of descending.
+    #   Ignored for unordered channels.
+    # @param revision_offset [Integer, nil] The offset of the position from a previous state
+    #   read, used with revision_epoch.
+    # @param revision_epoch [String, nil] The epoch of the position from a previous state
+    #   read. If the epoch changed, the call fails with an unrecoverable
+    #   position error.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapReadStateResult]
+    # @raise [Error]
+    def map_read_state(
+      channel:,
+      cursor: nil,
+      limit: nil,
+      key: nil,
+      asc: nil,
+      revision_offset: nil,
+      revision_epoch: nil,
+      timeout: nil
+    )
+      invoke("map_read_state", MapReadStateResult, timeout) do
+        Requests.map_read_state(
+          channel,
+          cursor,
+          limit,
+          key,
+          asc,
+          revision_offset,
+          revision_epoch
+        )
+      end
+    end
+
+    # Every entry of a map channel's state, a page at a time: limit is the page
+    # size. Every page after the first is read at the first one's revision - its
+    # position, as revision_offset and revision_epoch, unless the request sets
+    # them - so that a state reset between pages raises
+    # UnrecoverablePositionError instead of mixing two states: read again from
+    # the first page then. Entries changed while iterating may be seen in either
+    # version; for a consistent view, read the changes since the first page's
+    # position with map_read_stream. Each entry comes with that position, as
+    # a MapStateItem.
+    #
+    # Returns an Enumerator, or with a block, yields each item and returns nil. A
+    # page is read when the iteration reaches it, and leaving the iteration early
+    # reads no further page. An error raises from the iteration, after the items
+    # before it. The iteration lasts as long as the caller's loop: page_timeout
+    # bounds each page's request, as attempt_timeout bounds a retry's attempt.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param cursor [String, nil] The pagination cursor from the previous page. Empty starts
+    #   from the beginning.
+    # @param limit [Integer, nil] The maximum number of entries per page: -1 means no limit, 0
+    #   returns only the stream position. Page sizes may exceed it with the
+    #   Redis map broker.
+    # @param key [String, nil] Reads a single entry by exact key. cursor and limit are ignored
+    #   when it is set.
+    # @param asc [Boolean, nil] Sorts ordered state by score ascending instead of descending.
+    #   Ignored for unordered channels.
+    # @param revision_offset [Integer, nil] The offset of the position from a previous state
+    #   read, used with revision_epoch.
+    # @param revision_epoch [String, nil] The epoch of the position from a previous state
+    #   read. If the epoch changed, the call fails with an unrecoverable
+    #   position error.
+    # @param page_timeout [Numeric, nil] Seconds bounding each page's request, replacing
+    #   request_timeout for it, longer or shorter: request_timeout when nil. Zero is refused.
+    # @yieldparam item [MapStateItem]
+    # @return [Enumerator<MapStateItem>, nil]
+    # @raise [Error]
+    def map_read_state_all(
+      channel:,
+      cursor: nil,
+      limit: nil,
+      key: nil,
+      asc: nil,
+      revision_offset: nil,
+      revision_epoch: nil,
+      page_timeout: nil,
+      &block
+    )
+      pages("map_read_state", page_timeout, block) do
+        Requests.map_read_state(
+          channel,
+          cursor,
+          limit,
+          key,
+          asc,
+          revision_offset,
+          revision_epoch
+        )
+      end
+    end
+
+    # Reads the change stream of a map channel.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param since_offset [Integer, nil] Returns entries after this offset, used with
+    #   since_epoch.
+    # @param since_epoch [String, nil] The epoch of the since position. It must match the
+    #   current stream epoch.
+    # @param limit [Integer, nil] The maximum number of entries: -1 means no limit, 0 returns
+    #   only the stream position.
+    # @param reverse [Boolean, nil] Returns entries newest first.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapReadStreamResult]
+    # @raise [Error]
+    def map_read_stream(
+      channel:,
+      since_offset: nil,
+      since_epoch: nil,
+      limit: nil,
+      reverse: nil,
+      timeout: nil
+    )
+      invoke("map_read_stream", MapReadStreamResult, timeout) do
+        Requests.map_read_stream(
+          channel,
+          since_offset,
+          since_epoch,
+          limit,
+          reverse
+        )
+      end
+    end
+
+    # Returns statistics about a map channel.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapStatsResult]
+    # @raise [Error]
+    def map_stats(channel:, timeout: nil)
+      invoke("map_stats", MapStatsResult, timeout) do
+        Requests.map_stats(channel)
+      end
+    end
+
+    # Removes all state and stream data of a map channel.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [MapClearResult]
+    # @raise [Error]
+    def map_clear(channel:, timeout: nil)
+      invoke("map_clear", MapClearResult, timeout) do
+        Requests.map_clear(channel)
+      end
+    end
+
+    # Pushes data for a key directly to clients of a
+    # shared poll channel, without waiting for the next poll cycle. Requires
+    # versioned mode and publish_enabled on the namespace.
+    #
+    # @param channel [String, nil] The name of the shared poll channel. Required.
+    # @param key [String, nil] The item key. Required.
+    # @param data [Object, nil] The item data, delivered to clients as is.
+    # @param b64data [String, nil] Data as base64, for binary payloads. Centrifugo decodes it.
+    # @param version [Integer, nil] The item version, must be >= 1. Required. A version not
+    #   higher than the current one within the same epoch is silently dropped.
+    # @param epoch [String, nil] The channel-level publisher epoch. A change resets per-key
+    #   versions and unsubscribes current subscribers with insufficient state.
+    # @param timeout [Numeric, nil] Seconds bounding the call, replacing request_timeout, longer or shorter: request_timeout when nil. Zero is refused, as a negative is.
+    # @return [SharedPollPublishResult]
+    # @raise [Error]
+    def shared_poll_publish(
+      channel:,
+      key:,
+      version:,
+      data: nil,
+      b64data: nil,
+      epoch: nil,
+      timeout: nil
+    )
+      invoke("shared_poll_publish", SharedPollPublishResult, timeout) do
+        Requests.shared_poll_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          version,
+          epoch
+        )
+      end
+    end
+  end
+
+  # The commands of Batch, one per method of api.proto.
+  #
+  # @api private
+  module BatchMethods
+    # Publishes data into a channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel to publish into. Required.
+    # @param data [Object, nil] The payload to publish. Required unless b64data is set. In the
+    #   HTTP API it is any JSON value; over GRPC it may be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding this publication to the channel history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to the
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not published
+    #   again, and the first one's result is returned. It acts per channel;
+    #   results are kept for 5 minutes by default. The memory, Redis and
+    #   PostgreSQL brokers keep keys; the NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publication to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @return [Pending<PublishResult>]
+    def publish(
+      channel:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil
+    )
+      add("publish", PublishResult) do
+        Requests.publish(
+          channel,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Publishes the same data into many channels.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent, and raises BroadcastFailedChannelsError when any channel failed.
+    #
+    # @param channels [Array<String>] The list of channels to publish into. Required.
+    # @param data [Object, nil] The payload to publish into each channel. Required unless
+    #   b64data is set. In the HTTP API it is any JSON value; over GRPC it may
+    #   be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding the publications to the channels' history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to each
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries. It acts per
+    #   channel: a broadcast retried with the same key is not published again
+    #   into the channels which already have it. Results are kept for 5 minutes
+    #   by default. The memory, Redis and PostgreSQL brokers keep keys; the
+    #   NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publications to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @return [Pending<BroadcastResult>]
+    def broadcast(
+      channels:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil
+    )
+      add_broadcast do
+        Requests.broadcast(
+          channels,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Subscribes active sessions of a user to a channel
+    # (server-side subscription). It does not create a streaming subscription
+    # for the caller.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel to subscribe to. Required.
+    # @param user [String, nil] The ID of the user to subscribe. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the subscription expires.
+    # @param info [Object, nil] Custom channel info attached to the subscription, used in
+    #   presence and join/leave messages.
+    # @param b64info [String, nil] Info as base64, for binary. Centrifugo decodes it.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param data [Object, nil] Custom subscription data sent to the client in the Subscribe
+    #   push.
+    # @param b64data [String, nil] Data as base64, for binary. Centrifugo decodes it.
+    # @param recover_since [StreamPosition, Hash, nil] The stream position to recover publications from.
+    # @param override [SubscribeOptionOverride, Hash, nil] Dynamically overrides some channel options set in the
+    #   Centrifugo configuration.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] When user is empty, targets every connection on every node
+    #   instead of the anonymous-only bucket. No effect when user is non-empty.
+    #   Without label_filter it acts on every connection. Centrifugo PRO only.
+    # @return [Pending<SubscribeResult>]
+    def subscribe(
+      channel:,
+      user: nil,
+      expire_at: nil,
+      info: nil,
+      b64info: nil,
+      client: nil,
+      data: nil,
+      b64data: nil,
+      recover_since: nil,
+      override: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      add("subscribe", SubscribeResult) do
+        Requests.subscribe(
+          channel,
+          user,
+          expire_at,
+          info,
+          b64info,
+          client,
+          data,
+          b64data,
+          recover_since,
+          override,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Unsubscribes a user from a channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel to unsubscribe from. Required.
+    # @param user [String, nil] The ID of the user to unsubscribe. Required, unless all_users
+    #   is used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Pending<UnsubscribeResult>]
+    def unsubscribe(
+      channel:,
+      user: nil,
+      client: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      add("unsubscribe", UnsubscribeResult) do
+        Requests.unsubscribe(
+          channel,
+          user,
+          client,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Disconnects a user's connections.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param user [String, nil] The ID of the user to disconnect. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param disconnect [Disconnect, Hash, nil] A custom disconnect code and reason. If not set, clients
+    #   are disconnected with a force no-reconnect disconnect.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param whitelist [Array<String>] A list of client IDs to keep connected.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Pending<DisconnectResult>]
+    def disconnect(
+      user: nil,
+      disconnect: nil,
+      client: nil,
+      whitelist: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      add("disconnect", DisconnectResult) do
+        Requests.disconnect(
+          user,
+          disconnect,
+          client,
+          whitelist,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns the online presence of a channel: all clients
+    # currently subscribed to it. Presence must be enabled for the channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Pending<PresenceResult>]
+    def presence(channel:)
+      add("presence", PresenceResult) do
+        Requests.presence(channel)
+      end
+    end
+
+    # Returns short presence information of a channel: the
+    # number of clients and of unique users. Presence must be enabled for the
+    # channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Pending<PresenceStatsResult>]
+    def presence_stats(channel:)
+      add("presence_stats", PresenceStatsResult) do
+        Requests.presence_stats(channel)
+      end
+    end
+
+    # Returns publications from the history of a channel.
+    # History must be enabled for the channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param limit [Integer, nil] The maximum number of publications to return; -1 returns all
+    #   the channel keeps. If not set, only the current stream position is
+    #   returned, without publications.
+    # @param since [StreamPosition, Hash, nil] Returns publications after this stream position.
+    # @param reverse [Boolean, nil] Iterates in reverse order, from latest to earliest.
+    # @return [Pending<HistoryResult>]
+    def history(
+      channel:,
+      limit: nil,
+      since: nil,
+      reverse: nil
+    )
+      add("history", HistoryResult) do
+        Requests.history(channel, limit, since, reverse)
+      end
+    end
+
+    # Removes publications from the history of a channel.
+    # The current top stream position is kept, so clients do not get
+    # disconnected because of insufficient state.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Pending<HistoryRemoveResult>]
+    def history_remove(channel:)
+      add("history_remove", HistoryRemoveResult) do
+        Requests.history_remove(channel)
+      end
+    end
+
+    # Returns information about the running Centrifugo nodes.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @return [Pending<InfoResult>]
+    def info
+      add("info", InfoResult) do
+        Requests.info
+      end
+    end
+
+    # Refreshes a user's connections, mostly useful with
+    # unidirectional transports. Without expire_at the connections become
+    # non-expiring.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param user [String, nil] The ID of the user to refresh. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param expired [Boolean, nil] Marks the connections as expired and closes them with an
+    #   expired disconnect reason.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the connections expire.
+    # @param info [Object, nil] Attaches or replaces the connection info.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Pending<RefreshResult>]
+    def refresh(
+      user: nil,
+      client: nil,
+      expired: nil,
+      expire_at: nil,
+      info: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      add("refresh", RefreshResult) do
+        Requests.refresh(
+          user,
+          client,
+          expired,
+          expire_at,
+          info,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns active channels (with one or more subscribers).
+    # It can be heavy on large deployments: there is no pagination.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param pattern [String, nil] Filters channels by name, using gobwas/glob syntax.
+    # @return [Pending<ChannelsResult>]
+    def channels(pattern: nil)
+      add("channels", ChannelsResult) do
+        Requests.channels(pattern)
+      end
+    end
+
+    # Returns information about active connections, without
+    # the need to enable presence. At least one of user, expression or
+    # label_filter must be set. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param user [String, nil] Returns only the connections of this user ID.
+    # @param expression [String, nil] A CEL expression to filter connections.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the listing to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @return [Pending<ConnectionsResult>]
+    def connections(user: nil, expression: nil, label_filter: nil)
+      add("connections", ConnectionsResult) do
+        Requests.connections(user, expression, label_filter)
+      end
+    end
+
+    # Marks users as active and online now, and sets
+    # their state when one is given. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param users [Array<String>] The list of user IDs to update the status for. Required.
+    # @param state [String, nil] An optional custom state to store in the user status. It can
+    #   be restricted by the user_status.state_regex option.
+    # @return [Pending<UpdateUserStatusResult>]
+    def update_user_status(users:, state: nil)
+      add("update_user_status", UpdateUserStatusResult) do
+        Requests.update_user_status(users, state)
+      end
+    end
+
+    # Returns the status of users. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param users [Array<String>] The list of user IDs to get the status for. Required.
+    # @return [Pending<GetUserStatusResult>]
+    def get_user_status(users:)
+      add("get_user_status", GetUserStatusResult) do
+        Requests.get_user_status(users)
+      end
+    end
+
+    # Deletes the status of users. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param users [Array<String>] The list of user IDs to delete the status for. Required.
+    # @return [Pending<DeleteUserStatusResult>]
+    def delete_user_status(users:)
+      add("delete_user_status", DeleteUserStatusResult) do
+        Requests.delete_user_status(users)
+      end
+    end
+
+    # Blocks a user: the user is disconnected and can not
+    # connect again until unblocked or the block expires. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the block expires. Optional,
+    #   but a reasonably small value is recommended to keep the set of blocked
+    #   users small.
+    # @param user [String, nil] The ID of the user to block. Required.
+    # @return [Pending<BlockUserResult>]
+    def block_user(user:, expire_at: nil)
+      add("block_user", BlockUserResult) do
+        Requests.block_user(expire_at, user)
+      end
+    end
+
+    # Unblocks a user. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param user [String, nil] The ID of the user to unblock. Required.
+    # @return [Pending<UnblockUserResult>]
+    def unblock_user(user:)
+      add("unblock_user", UnblockUserResult) do
+        Requests.unblock_user(user)
+      end
+    end
+
+    # Revokes a token by its unique ID (jti claim of a JWT).
+    # Clients using the token are disconnected shortly, and can not connect
+    # with it again. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the revocation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param uid [String, nil] The unique ID of the token to revoke (jti claim). Required.
+    # @return [Pending<RevokeTokenResult>]
+    def revoke_token(uid:, expire_at: nil)
+      add("revoke_token", RevokeTokenResult) do
+        Requests.revoke_token(expire_at, uid)
+      end
+    end
+
+    # Revokes all tokens of a user issued before a
+    # certain time (based on the iat claim of a JWT). Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the invalidation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param user [String, nil] The ID of the user whose tokens to invalidate. Required. ""
+    #   invalidates the tokens of anonymous users.
+    # @param issued_before [Integer, nil] The Unix time in seconds: tokens issued before it are
+    #   considered revoked. If not set, the current time is used.
+    # @param channel [String, nil] Limits the invalidation to subscription tokens for this
+    #   channel.
+    # @return [Pending<InvalidateUserTokensResult>]
+    def invalidate_user_tokens(
+      user:,
+      expire_at: nil,
+      issued_before: nil,
+      channel: nil
+    )
+      add("invalidate_user_tokens", InvalidateUserTokensResult) do
+        Requests.invalidate_user_tokens(expire_at, user, issued_before, channel)
+      end
+    end
+
+    # Registers a device for push notifications, or
+    # updates a registered one. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param id [String, nil] The device ID. Omit it on first registration: Centrifugo
+    #   generates one and returns it. Pass the stored value to update the
+    #   device.
+    # @param provider [String, nil] The provider of the device token. Required. One of: fcm,
+    #   hms, apns, webpush.
+    # @param token [String, nil] The push token of the device. For webpush, it is the browser
+    #   PushSubscription serialized as a JSON string. Required.
+    # @param platform [String, nil] The device platform. Required. One of: ios, android, web.
+    # @param user [String, nil] The user associated with the device.
+    # @param meta [Hash{String => String}] Additional custom metadata of the device.
+    # @param topics [Array<String>] The full list of the device's topic subscriptions, replacing
+    #   the previous one. The user's topics are attached automatically.
+    # @param timezone [String, nil] The IANA time zone of the device user, for example
+    #   Europe/Nicosia.
+    # @param locale [String, nil] The locale of the device user as an IETF BCP 47 language
+    #   tag, for example en-US.
+    # @return [Pending<DeviceRegisterResult>]
+    def device_register(
+      provider:,
+      token:,
+      platform:,
+      id: nil,
+      user: nil,
+      meta: nil,
+      topics: nil,
+      timezone: nil,
+      locale: nil
+    )
+      add("device_register", DeviceRegisterResult) do
+        Requests.device_register(
+          id,
+          provider,
+          token,
+          platform,
+          user,
+          meta,
+          topics,
+          timezone,
+          locale
+        )
+      end
+    end
+
+    # Updates registered devices, selected by ids and/or
+    # users. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param ids [Array<String>] Selects devices by ID.
+    # @param users [Array<String>] Selects devices by user.
+    # @param user_update [DeviceUserUpdate, Hash, nil] Changes the user ID of the devices. It does not re-sync
+    #   user-bound topics; use DeviceRegisterRequest to assign a device to
+    #   another user.
+    # @param meta_update [DeviceMetaUpdate, Hash, nil] Updates the device meta.
+    # @param topics_update [DeviceTopicsUpdate, Hash, nil] Updates the device topics.
+    # @param timezone_update [DeviceTimezoneUpdate, Hash, nil] Updates the device timezone.
+    # @param locale_update [DeviceLocaleUpdate, Hash, nil] Updates the device locale.
+    # @return [Pending<DeviceUpdateResult>]
+    def device_update(
+      ids: nil,
+      users: nil,
+      user_update: nil,
+      meta_update: nil,
+      topics_update: nil,
+      timezone_update: nil,
+      locale_update: nil
+    )
+      add("device_update", DeviceUpdateResult) do
+        Requests.device_update(
+          ids,
+          users,
+          user_update,
+          meta_update,
+          topics_update,
+          timezone_update,
+          locale_update
+        )
+      end
+    end
+
+    # Removes devices, selected by ids and/or users.
+    # Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param ids [Array<String>] Selects devices to remove by ID.
+    # @param users [Array<String>] Selects devices to remove by user.
+    # @return [Pending<DeviceRemoveResult>]
+    def device_remove(ids: nil, users: nil)
+      add("device_remove", DeviceRemoveResult) do
+        Requests.device_remove(ids, users)
+      end
+    end
+
+    # Returns a paginated list of registered devices.
+    # Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param filter [DeviceFilter, Hash, nil] Selects the devices to list: all of them when unset.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_meta [Boolean, nil] Includes meta of each device.
+    # @param include_topics [Boolean, nil] Includes topics of each device.
+    # @param include_webpush_keys [Boolean, nil] Includes webpush_keys of each device (webpush
+    #   only).
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of devices to return.
+    # @return [Pending<DeviceListResult>]
+    def device_list(
+      filter: nil,
+      include_total_count: nil,
+      include_meta: nil,
+      include_topics: nil,
+      include_webpush_keys: nil,
+      cursor: nil,
+      limit: nil
+    )
+      add("device_list", DeviceListResult) do
+        Requests.device_list(
+          filter,
+          include_total_count,
+          include_meta,
+          include_topics,
+          include_webpush_keys,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Returns a paginated list of device topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param filter [DeviceTopicFilter, Hash, nil] Selects the device topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_device [Boolean, nil] Includes the Device of each item.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @return [Pending<DeviceTopicListResult>]
+    def device_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      include_device: nil,
+      cursor: nil,
+      limit: nil
+    )
+      add("device_topic_list", DeviceTopicListResult) do
+        Requests.device_topic_list(
+          filter,
+          include_total_count,
+          include_device,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Changes the topics of a device. The device topic
+    # list is what decides who gets a push sent to a topic.
+    # Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param device_id [String, nil] The ID of the device. Required.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @param user [String, nil] An optional ownership guard: the update is applied only if the
+    #   device currently belongs to this user. Otherwise the call fails with a
+    #   conflict error (or not found if there is no such device).
+    # @return [Pending<DeviceTopicUpdateResult>]
+    def device_topic_update(
+      device_id:,
+      op:,
+      topics: nil,
+      user: nil
+    )
+      add("device_topic_update", DeviceTopicUpdateResult) do
+        Requests.device_topic_update(device_id, op, topics, user)
+      end
+    end
+
+    # Returns a paginated list of user topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param filter [UserTopicFilter, Hash, nil] Selects the user topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @return [Pending<UserTopicListResult>]
+    def user_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      cursor: nil,
+      limit: nil
+    )
+      add("user_topic_list", UserTopicListResult) do
+        Requests.user_topic_list(filter, include_total_count, cursor, limit)
+      end
+    end
+
+    # Changes the topics of a user. The change is also
+    # applied to the user's registered devices. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param user [String, nil] The user ID. Required. "" updates the global binding, which every
+    #   device - anonymous ones included - gets on its next device_register.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @return [Pending<UserTopicUpdateResult>]
+    def user_topic_update(user:, op:, topics: nil)
+      add("user_topic_update", UserTopicUpdateResult) do
+        Requests.user_topic_update(user, op, topics)
+      end
+    end
+
+    # Sends a push notification. The request is
+    # queued and sent to the provider by Centrifugo workers.
+    # Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param recipient [PushRecipient, Hash, nil] Who receives the notification. Required.
+    # @param notification [PushNotification, Hash, nil] The notification to send. Required.
+    # @param uid [String, nil] A unique identifier of the request, can be used to cancel the
+    #   push. UUID v4 is recommended; different requests must use different
+    #   uids.
+    # @param send_at [Integer, nil] The Unix time in seconds when to send the notification. If
+    #   not set, the notification is sent immediately.
+    # @param optimize_for_reliability [Boolean, nil] Makes processing heavier, but tolerates edge
+    #   cases, like not losing inflight pushes when the queue is briefly
+    #   unavailable.
+    # @param limit_strategy [PushLimitStrategy, Hash, nil] Sets time constraints and rate limits. Only applies
+    #   with a filter recipient; devices are then processed one by one
+    #   instead of in batches. Needs notification.expire_at: a push the limits
+    #   hold back is not tried forever.
+    # @param analytics_uid [String, nil] The identifier for push notification analytics. If
+    #   not set, uid is used.
+    # @param localizations [Hash{String => PushLocalization, Hash}] Optional per language/locale localizations. Setting
+    #   them enables templating.
+    # @param use_templating [Boolean, nil] Enables templating of the notification. Only works
+    #   with a filter recipient.
+    # @param use_meta [Boolean, nil] Additionally loads device meta while sending, making it
+    #   available in templating.
+    # @return [Pending<SendPushNotificationResult>]
+    def send_push_notification(
+      recipient:,
+      notification:,
+      uid: nil,
+      send_at: nil,
+      optimize_for_reliability: nil,
+      limit_strategy: nil,
+      analytics_uid: nil,
+      localizations: nil,
+      use_templating: nil,
+      use_meta: nil
+    )
+      add("send_push_notification", SendPushNotificationResult) do
+        Requests.send_push_notification(
+          recipient,
+          notification,
+          uid,
+          send_at,
+          optimize_for_reliability,
+          limit_strategy,
+          analytics_uid,
+          localizations,
+          use_templating,
+          use_meta
+        )
+      end
+    end
+
+    # Saves the delivery or interaction status of a
+    # push notification to analytics. Experimental. Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param analytics_uid [String, nil] The analytics_uid of the push notification (as in
+    #   SendPushNotificationRequest). Required.
+    # @param status [String, nil] The status of the push notification. Required. One of:
+    #   delivered, interacted.
+    # @param device_id [String, nil] The Centrifugo device ID. Required.
+    # @param msg_id [String, nil] The message ID issued by the provider.
+    # @return [Pending<UpdatePushStatusResult>]
+    def update_push_status(
+      analytics_uid:,
+      status:,
+      device_id:,
+      msg_id: nil
+    )
+      add("update_push_status", UpdatePushStatusResult) do
+        Requests.update_push_status(analytics_uid, status, device_id, msg_id)
+      end
+    end
+
+    # Cancels a delayed push notification (sent with
+    # send_at). Centrifugo PRO only.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param uid [String, nil] The uid of the push notification to cancel. Required.
+    # @return [Pending<CancelPushResult>]
+    def cancel_push(uid:)
+      add("cancel_push", CancelPushResult) do
+        Requests.cancel_push(uid)
+      end
+    end
+
+    # Publishes or updates a key in a map channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The entry key. Required.
+    # @param data [Object, nil] The entry data. In the HTTP API it is any JSON value; over GRPC
+    #   it may be binary.
+    # @param b64data [String, nil] Data as base64, for binary over the HTTP API. Centrifugo
+    #   decodes it.
+    # @param stream_data [Object, nil] Currently not used by the server API.
+    # @param b64stream_data [String, nil] Currently not used by the server API.
+    # @param tags [Hash{String => String}] Key-value metadata attached to the publication.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not applied
+    #   again, and its result has the first one's position, with suppressed
+    #   set and suppress_reason "idempotency". It acts per channel; keys are
+    #   kept for 5 minutes by default. Every map broker - memory, Redis and
+    #   PostgreSQL - keeps keys.
+    # @param delta [Boolean, nil] Enables delta compression for this publication.
+    # @param version [Integer, nil] A per-key version: publications with a version not higher
+    #   than the key's current one are suppressed.
+    # @param version_epoch [String, nil] Scopes version. A different epoch resets version
+    #   comparison.
+    # @param score [Integer, nil] Currently not used by the server API.
+    # @param key_mode [String, nil] Makes the publish conditional: if_new writes only if the key
+    #   does not exist, if_exists only if it exists. Empty always writes.
+    #   One of: if_new, if_exists.
+    # @return [Pending<MapPublishResult>]
+    def map_publish(
+      channel:,
+      key:,
+      data: nil,
+      b64data: nil,
+      stream_data: nil,
+      b64stream_data: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      score: nil,
+      key_mode: nil
+    )
+      add("map_publish", MapPublishResult) do
+        Requests.map_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          stream_data,
+          b64stream_data,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch,
+          score,
+          key_mode
+        )
+      end
+    end
+
+    # Removes a key from a map channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The key to remove. Required.
+    # @param idempotency_key [String, nil] Drops duplicate removals upon retries, as it does for
+    #   MapPublishRequest: a removal with a key already used in the channel is
+    #   not applied again, and its result is suppressed with suppress_reason
+    #   "idempotency". Keys are kept for 5 minutes by default.
+    # @return [Pending<MapRemoveResult>]
+    def map_remove(channel:, key:, idempotency_key: nil)
+      add("map_remove", MapRemoveResult) do
+        Requests.map_remove(channel, key, idempotency_key)
+      end
+    end
+
+    # Reads the current state of a map channel, with
+    # optional pagination.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param cursor [String, nil] The pagination cursor from the previous page. Empty starts
+    #   from the beginning.
+    # @param limit [Integer, nil] The maximum number of entries per page: -1 means no limit, 0
+    #   returns only the stream position. Page sizes may exceed it with the
+    #   Redis map broker.
+    # @param key [String, nil] Reads a single entry by exact key. cursor and limit are ignored
+    #   when it is set.
+    # @param asc [Boolean, nil] Sorts ordered state by score ascending instead of descending.
+    #   Ignored for unordered channels.
+    # @param revision_offset [Integer, nil] The offset of the position from a previous state
+    #   read, used with revision_epoch.
+    # @param revision_epoch [String, nil] The epoch of the position from a previous state
+    #   read. If the epoch changed, the call fails with an unrecoverable
+    #   position error.
+    # @return [Pending<MapReadStateResult>]
+    def map_read_state(
+      channel:,
+      cursor: nil,
+      limit: nil,
+      key: nil,
+      asc: nil,
+      revision_offset: nil,
+      revision_epoch: nil
+    )
+      add("map_read_state", MapReadStateResult) do
+        Requests.map_read_state(
+          channel,
+          cursor,
+          limit,
+          key,
+          asc,
+          revision_offset,
+          revision_epoch
+        )
+      end
+    end
+
+    # Reads the change stream of a map channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param since_offset [Integer, nil] Returns entries after this offset, used with
+    #   since_epoch.
+    # @param since_epoch [String, nil] The epoch of the since position. It must match the
+    #   current stream epoch.
+    # @param limit [Integer, nil] The maximum number of entries: -1 means no limit, 0 returns
+    #   only the stream position.
+    # @param reverse [Boolean, nil] Returns entries newest first.
+    # @return [Pending<MapReadStreamResult>]
+    def map_read_stream(
+      channel:,
+      since_offset: nil,
+      since_epoch: nil,
+      limit: nil,
+      reverse: nil
+    )
+      add("map_read_stream", MapReadStreamResult) do
+        Requests.map_read_stream(
+          channel,
+          since_offset,
+          since_epoch,
+          limit,
+          reverse
+        )
+      end
+    end
+
+    # Returns statistics about a map channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @return [Pending<MapStatsResult>]
+    def map_stats(channel:)
+      add("map_stats", MapStatsResult) do
+        Requests.map_stats(channel)
+      end
+    end
+
+    # Removes all state and stream data of a map channel.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @return [Pending<MapClearResult>]
+    def map_clear(channel:)
+      add("map_clear", MapClearResult) do
+        Requests.map_clear(channel)
+      end
+    end
+
+    # Pushes data for a key directly to clients of a
+    # shared poll channel, without waiting for the next poll cycle. Requires
+    # versioned mode and publish_enabled on the namespace.
+    #
+    # Adds the command to the batch: its Pending holds the result once the batch
+    # is sent.
+    #
+    # @param channel [String, nil] The name of the shared poll channel. Required.
+    # @param key [String, nil] The item key. Required.
+    # @param data [Object, nil] The item data, delivered to clients as is.
+    # @param b64data [String, nil] Data as base64, for binary payloads. Centrifugo decodes it.
+    # @param version [Integer, nil] The item version, must be >= 1. Required. A version not
+    #   higher than the current one within the same epoch is silently dropped.
+    # @param epoch [String, nil] The channel-level publisher epoch. A change resets per-key
+    #   versions and unsubscribes current subscribers with insufficient state.
+    # @return [Pending<SharedPollPublishResult>]
+    def shared_poll_publish(
+      channel:,
+      key:,
+      version:,
+      data: nil,
+      b64data: nil,
+      epoch: nil
+    )
+      add("shared_poll_publish", SharedPollPublishResult) do
+        Requests.shared_poll_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          version,
+          epoch
+        )
+      end
+    end
+  end
+
+  # The commands of Command, one per method of api.proto.
+  #
+  # @api private
+  module CommandMethods
+    # Publishes data into a channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel to publish into. Required.
+    # @param data [Object, nil] The payload to publish. Required unless b64data is set. In the
+    #   HTTP API it is any JSON value; over GRPC it may be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding this publication to the channel history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to the
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not published
+    #   again, and the first one's result is returned. It acts per channel;
+    #   results are kept for 5 minutes by default. The memory, Redis and
+    #   PostgreSQL brokers keep keys; the NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publication to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def publish(
+      channel:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil
+    )
+      build("publish") do
+        Requests.publish(
+          channel,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Publishes the same data into many channels.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channels [Array<String>] The list of channels to publish into. Required.
+    # @param data [Object, nil] The payload to publish into each channel. Required unless
+    #   b64data is set. In the HTTP API it is any JSON value; over GRPC it may
+    #   be binary.
+    # @param b64data [String, nil] A base64-encoded binary payload, an alternative to `data` to
+    #   send binary over the HTTP API. Centrifugo decodes it before publishing.
+    # @param skip_history [Boolean, nil] Skips adding the publications to the channels' history.
+    # @param tags [Hash{String => String}] A map of arbitrary string keys and values attached to each
+    #   publication and delivered to clients.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries. It acts per
+    #   channel: a broadcast retried with the same key is not published again
+    #   into the channels which already have it. Results are kept for 5 minutes
+    #   by default. The memory, Redis and PostgreSQL brokers keep keys; the
+    #   NATS broker ignores them.
+    # @param delta [Boolean, nil] Tells Centrifugo to construct a delta update, if possible, when
+    #   broadcasting the publications to subscribers.
+    # @param version [Integer, nil] When > 0, the version of the document being sent:
+    #   publications with a version less than or equal to one already seen are
+    #   ignored. Only works in channels with history enabled.
+    # @param version_epoch [String, nil] The epoch of version. When it changes, Centrifugo
+    #   accepts the publication even if its version is lower than before.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def broadcast(
+      channels:,
+      data: nil,
+      b64data: nil,
+      skip_history: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil
+    )
+      build("broadcast") do
+        Requests.broadcast(
+          channels,
+          data,
+          b64data,
+          skip_history,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch
+        )
+      end
+    end
+
+    # Subscribes active sessions of a user to a channel
+    # (server-side subscription). It does not create a streaming subscription
+    # for the caller.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel to subscribe to. Required.
+    # @param user [String, nil] The ID of the user to subscribe. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the subscription expires.
+    # @param info [Object, nil] Custom channel info attached to the subscription, used in
+    #   presence and join/leave messages.
+    # @param b64info [String, nil] Info as base64, for binary. Centrifugo decodes it.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param data [Object, nil] Custom subscription data sent to the client in the Subscribe
+    #   push.
+    # @param b64data [String, nil] Data as base64, for binary. Centrifugo decodes it.
+    # @param recover_since [StreamPosition, Hash, nil] The stream position to recover publications from.
+    # @param override [SubscribeOptionOverride, Hash, nil] Dynamically overrides some channel options set in the
+    #   Centrifugo configuration.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] When user is empty, targets every connection on every node
+    #   instead of the anonymous-only bucket. No effect when user is non-empty.
+    #   Without label_filter it acts on every connection. Centrifugo PRO only.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def subscribe(
+      channel:,
+      user: nil,
+      expire_at: nil,
+      info: nil,
+      b64info: nil,
+      client: nil,
+      data: nil,
+      b64data: nil,
+      recover_since: nil,
+      override: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      build("subscribe") do
+        Requests.subscribe(
+          channel,
+          user,
+          expire_at,
+          info,
+          b64info,
+          client,
+          data,
+          b64data,
+          recover_since,
+          override,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Unsubscribes a user from a channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel to unsubscribe from. Required.
+    # @param user [String, nil] The ID of the user to unsubscribe. Required, unless all_users
+    #   is used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def unsubscribe(
+      channel:,
+      user: nil,
+      client: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      build("unsubscribe") do
+        Requests.unsubscribe(
+          channel,
+          user,
+          client,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Disconnects a user's connections.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param user [String, nil] The ID of the user to disconnect. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param disconnect [Disconnect, Hash, nil] A custom disconnect code and reason. If not set, clients
+    #   are disconnected with a force no-reconnect disconnect.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param whitelist [Array<String>] A list of client IDs to keep connected.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def disconnect(
+      user: nil,
+      disconnect: nil,
+      client: nil,
+      whitelist: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      build("disconnect") do
+        Requests.disconnect(
+          user,
+          disconnect,
+          client,
+          whitelist,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns the online presence of a channel: all clients
+    # currently subscribed to it. Presence must be enabled for the channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def presence(channel:)
+      build("presence") do
+        Requests.presence(channel)
+      end
+    end
+
+    # Returns short presence information of a channel: the
+    # number of clients and of unique users. Presence must be enabled for the
+    # channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def presence_stats(channel:)
+      build("presence_stats") do
+        Requests.presence_stats(channel)
+      end
+    end
+
+    # Returns publications from the history of a channel.
+    # History must be enabled for the channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @param limit [Integer, nil] The maximum number of publications to return; -1 returns all
+    #   the channel keeps. If not set, only the current stream position is
+    #   returned, without publications.
+    # @param since [StreamPosition, Hash, nil] Returns publications after this stream position.
+    # @param reverse [Boolean, nil] Iterates in reverse order, from latest to earliest.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def history(
+      channel:,
+      limit: nil,
+      since: nil,
+      reverse: nil
+    )
+      build("history") do
+        Requests.history(channel, limit, since, reverse)
+      end
+    end
+
+    # Removes publications from the history of a channel.
+    # The current top stream position is kept, so clients do not get
+    # disconnected because of insufficient state.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the channel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def history_remove(channel:)
+      build("history_remove") do
+        Requests.history_remove(channel)
+      end
+    end
+
+    # Returns information about the running Centrifugo nodes.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def info
+      build("info") do
+        Requests.info
+      end
+    end
+
+    # Refreshes a user's connections, mostly useful with
+    # unidirectional transports. Without expire_at the connections become
+    # non-expiring.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param user [String, nil] The ID of the user to refresh. Required, unless all_users is
+    #   used in Centrifugo PRO.
+    # @param client [String, nil] Limits the call to the connection with this client ID. user is
+    #   still required.
+    # @param expired [Boolean, nil] Marks the connections as expired and closes them with an
+    #   expired disconnect reason.
+    # @param expire_at [Integer, nil] The Unix time in seconds when the connections expire.
+    # @param info [Object, nil] Attaches or replaces the connection info.
+    # @param session [String, nil] Limits the call to the connection with this session ID. user
+    #   is still required.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the call to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @param all_users [Boolean, nil] Works as SubscribeRequest.all_users. Centrifugo PRO only.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def refresh(
+      user: nil,
+      client: nil,
+      expired: nil,
+      expire_at: nil,
+      info: nil,
+      session: nil,
+      label_filter: nil,
+      all_users: nil
+    )
+      build("refresh") do
+        Requests.refresh(
+          user,
+          client,
+          expired,
+          expire_at,
+          info,
+          session,
+          label_filter,
+          all_users
+        )
+      end
+    end
+
+    # Returns active channels (with one or more subscribers).
+    # It can be heavy on large deployments: there is no pagination.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param pattern [String, nil] Filters channels by name, using gobwas/glob syntax.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def channels(pattern: nil)
+      build("channels") do
+        Requests.channels(pattern)
+      end
+    end
+
+    # Returns information about active connections, without
+    # the need to enable presence. At least one of user, expression or
+    # label_filter must be set. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param user [String, nil] Returns only the connections of this user ID.
+    # @param expression [String, nil] A CEL expression to filter connections.
+    # @param label_filter [FilterNode, Hash, nil] Restricts the listing to clients whose labels match this
+    #   filter. Centrifugo PRO only.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def connections(user: nil, expression: nil, label_filter: nil)
+      build("connections") do
+        Requests.connections(user, expression, label_filter)
+      end
+    end
+
+    # Marks users as active and online now, and sets
+    # their state when one is given. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param users [Array<String>] The list of user IDs to update the status for. Required.
+    # @param state [String, nil] An optional custom state to store in the user status. It can
+    #   be restricted by the user_status.state_regex option.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def update_user_status(users:, state: nil)
+      build("update_user_status") do
+        Requests.update_user_status(users, state)
+      end
+    end
+
+    # Returns the status of users. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param users [Array<String>] The list of user IDs to get the status for. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def get_user_status(users:)
+      build("get_user_status") do
+        Requests.get_user_status(users)
+      end
+    end
+
+    # Deletes the status of users. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param users [Array<String>] The list of user IDs to delete the status for. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def delete_user_status(users:)
+      build("delete_user_status") do
+        Requests.delete_user_status(users)
+      end
+    end
+
+    # Blocks a user: the user is disconnected and can not
+    # connect again until unblocked or the block expires. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the block expires. Optional,
+    #   but a reasonably small value is recommended to keep the set of blocked
+    #   users small.
+    # @param user [String, nil] The ID of the user to block. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def block_user(user:, expire_at: nil)
+      build("block_user") do
+        Requests.block_user(expire_at, user)
+      end
+    end
+
+    # Unblocks a user. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param user [String, nil] The ID of the user to unblock. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def unblock_user(user:)
+      build("unblock_user") do
+        Requests.unblock_user(user)
+      end
+    end
+
+    # Revokes a token by its unique ID (jti claim of a JWT).
+    # Clients using the token are disconnected shortly, and can not connect
+    # with it again. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the revocation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param uid [String, nil] The unique ID of the token to revoke (jti claim). Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def revoke_token(uid:, expire_at: nil)
+      build("revoke_token") do
+        Requests.revoke_token(expire_at, uid)
+      end
+    end
+
+    # Revokes all tokens of a user issued before a
+    # certain time (based on the iat claim of a JWT). Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param expire_at [Integer, nil] The Unix time in seconds when the invalidation expires.
+    #   Optional, but a value matching the token expiration is recommended.
+    # @param user [String, nil] The ID of the user whose tokens to invalidate. Required. ""
+    #   invalidates the tokens of anonymous users.
+    # @param issued_before [Integer, nil] The Unix time in seconds: tokens issued before it are
+    #   considered revoked. If not set, the current time is used.
+    # @param channel [String, nil] Limits the invalidation to subscription tokens for this
+    #   channel.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def invalidate_user_tokens(
+      user:,
+      expire_at: nil,
+      issued_before: nil,
+      channel: nil
+    )
+      build("invalidate_user_tokens") do
+        Requests.invalidate_user_tokens(expire_at, user, issued_before, channel)
+      end
+    end
+
+    # Registers a device for push notifications, or
+    # updates a registered one. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param id [String, nil] The device ID. Omit it on first registration: Centrifugo
+    #   generates one and returns it. Pass the stored value to update the
+    #   device.
+    # @param provider [String, nil] The provider of the device token. Required. One of: fcm,
+    #   hms, apns, webpush.
+    # @param token [String, nil] The push token of the device. For webpush, it is the browser
+    #   PushSubscription serialized as a JSON string. Required.
+    # @param platform [String, nil] The device platform. Required. One of: ios, android, web.
+    # @param user [String, nil] The user associated with the device.
+    # @param meta [Hash{String => String}] Additional custom metadata of the device.
+    # @param topics [Array<String>] The full list of the device's topic subscriptions, replacing
+    #   the previous one. The user's topics are attached automatically.
+    # @param timezone [String, nil] The IANA time zone of the device user, for example
+    #   Europe/Nicosia.
+    # @param locale [String, nil] The locale of the device user as an IETF BCP 47 language
+    #   tag, for example en-US.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_register(
+      provider:,
+      token:,
+      platform:,
+      id: nil,
+      user: nil,
+      meta: nil,
+      topics: nil,
+      timezone: nil,
+      locale: nil
+    )
+      build("device_register") do
+        Requests.device_register(
+          id,
+          provider,
+          token,
+          platform,
+          user,
+          meta,
+          topics,
+          timezone,
+          locale
+        )
+      end
+    end
+
+    # Updates registered devices, selected by ids and/or
+    # users. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param ids [Array<String>] Selects devices by ID.
+    # @param users [Array<String>] Selects devices by user.
+    # @param user_update [DeviceUserUpdate, Hash, nil] Changes the user ID of the devices. It does not re-sync
+    #   user-bound topics; use DeviceRegisterRequest to assign a device to
+    #   another user.
+    # @param meta_update [DeviceMetaUpdate, Hash, nil] Updates the device meta.
+    # @param topics_update [DeviceTopicsUpdate, Hash, nil] Updates the device topics.
+    # @param timezone_update [DeviceTimezoneUpdate, Hash, nil] Updates the device timezone.
+    # @param locale_update [DeviceLocaleUpdate, Hash, nil] Updates the device locale.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_update(
+      ids: nil,
+      users: nil,
+      user_update: nil,
+      meta_update: nil,
+      topics_update: nil,
+      timezone_update: nil,
+      locale_update: nil
+    )
+      build("device_update") do
+        Requests.device_update(
+          ids,
+          users,
+          user_update,
+          meta_update,
+          topics_update,
+          timezone_update,
+          locale_update
+        )
+      end
+    end
+
+    # Removes devices, selected by ids and/or users.
+    # Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param ids [Array<String>] Selects devices to remove by ID.
+    # @param users [Array<String>] Selects devices to remove by user.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_remove(ids: nil, users: nil)
+      build("device_remove") do
+        Requests.device_remove(ids, users)
+      end
+    end
+
+    # Returns a paginated list of registered devices.
+    # Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param filter [DeviceFilter, Hash, nil] Selects the devices to list: all of them when unset.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_meta [Boolean, nil] Includes meta of each device.
+    # @param include_topics [Boolean, nil] Includes topics of each device.
+    # @param include_webpush_keys [Boolean, nil] Includes webpush_keys of each device (webpush
+    #   only).
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of devices to return.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_list(
+      filter: nil,
+      include_total_count: nil,
+      include_meta: nil,
+      include_topics: nil,
+      include_webpush_keys: nil,
+      cursor: nil,
+      limit: nil
+    )
+      build("device_list") do
+        Requests.device_list(
+          filter,
+          include_total_count,
+          include_meta,
+          include_topics,
+          include_webpush_keys,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Returns a paginated list of device topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param filter [DeviceTopicFilter, Hash, nil] Selects the device topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param include_device [Boolean, nil] Includes the Device of each item.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      include_device: nil,
+      cursor: nil,
+      limit: nil
+    )
+      build("device_topic_list") do
+        Requests.device_topic_list(
+          filter,
+          include_total_count,
+          include_device,
+          cursor,
+          limit
+        )
+      end
+    end
+
+    # Changes the topics of a device. The device topic
+    # list is what decides who gets a push sent to a topic.
+    # Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param device_id [String, nil] The ID of the device. Required.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @param user [String, nil] An optional ownership guard: the update is applied only if the
+    #   device currently belongs to this user. Otherwise the call fails with a
+    #   conflict error (or not found if there is no such device).
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def device_topic_update(
+      device_id:,
+      op:,
+      topics: nil,
+      user: nil
+    )
+      build("device_topic_update") do
+        Requests.device_topic_update(device_id, op, topics, user)
+      end
+    end
+
+    # Returns a paginated list of user topic
+    # subscriptions. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param filter [UserTopicFilter, Hash, nil] Selects the user topics to list.
+    # @param include_total_count [Boolean, nil] Includes the total count for the filter in the
+    #   result.
+    # @param cursor [String, nil] The pagination cursor: next_cursor of the previous page,
+    #   empty for the first page.
+    # @param limit [Integer, nil] The maximum number of items to return.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def user_topic_list(
+      filter: nil,
+      include_total_count: nil,
+      cursor: nil,
+      limit: nil
+    )
+      build("user_topic_list") do
+        Requests.user_topic_list(filter, include_total_count, cursor, limit)
+      end
+    end
+
+    # Changes the topics of a user. The change is also
+    # applied to the user's registered devices. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param user [String, nil] The user ID. Required. "" updates the global binding, which every
+    #   device - anonymous ones included - gets on its next device_register.
+    # @param op [String, nil] The operation. Required. One of: add, remove, set.
+    # @param topics [Array<String>] The topics for the operation.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def user_topic_update(user:, op:, topics: nil)
+      build("user_topic_update") do
+        Requests.user_topic_update(user, op, topics)
+      end
+    end
+
+    # Sends a push notification. The request is
+    # queued and sent to the provider by Centrifugo workers.
+    # Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param recipient [PushRecipient, Hash, nil] Who receives the notification. Required.
+    # @param notification [PushNotification, Hash, nil] The notification to send. Required.
+    # @param uid [String, nil] A unique identifier of the request, can be used to cancel the
+    #   push. UUID v4 is recommended; different requests must use different
+    #   uids.
+    # @param send_at [Integer, nil] The Unix time in seconds when to send the notification. If
+    #   not set, the notification is sent immediately.
+    # @param optimize_for_reliability [Boolean, nil] Makes processing heavier, but tolerates edge
+    #   cases, like not losing inflight pushes when the queue is briefly
+    #   unavailable.
+    # @param limit_strategy [PushLimitStrategy, Hash, nil] Sets time constraints and rate limits. Only applies
+    #   with a filter recipient; devices are then processed one by one
+    #   instead of in batches. Needs notification.expire_at: a push the limits
+    #   hold back is not tried forever.
+    # @param analytics_uid [String, nil] The identifier for push notification analytics. If
+    #   not set, uid is used.
+    # @param localizations [Hash{String => PushLocalization, Hash}] Optional per language/locale localizations. Setting
+    #   them enables templating.
+    # @param use_templating [Boolean, nil] Enables templating of the notification. Only works
+    #   with a filter recipient.
+    # @param use_meta [Boolean, nil] Additionally loads device meta while sending, making it
+    #   available in templating.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def send_push_notification(
+      recipient:,
+      notification:,
+      uid: nil,
+      send_at: nil,
+      optimize_for_reliability: nil,
+      limit_strategy: nil,
+      analytics_uid: nil,
+      localizations: nil,
+      use_templating: nil,
+      use_meta: nil
+    )
+      build("send_push_notification") do
+        Requests.send_push_notification(
+          recipient,
+          notification,
+          uid,
+          send_at,
+          optimize_for_reliability,
+          limit_strategy,
+          analytics_uid,
+          localizations,
+          use_templating,
+          use_meta
+        )
+      end
+    end
+
+    # Saves the delivery or interaction status of a
+    # push notification to analytics. Experimental. Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param analytics_uid [String, nil] The analytics_uid of the push notification (as in
+    #   SendPushNotificationRequest). Required.
+    # @param status [String, nil] The status of the push notification. Required. One of:
+    #   delivered, interacted.
+    # @param device_id [String, nil] The Centrifugo device ID. Required.
+    # @param msg_id [String, nil] The message ID issued by the provider.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def update_push_status(
+      analytics_uid:,
+      status:,
+      device_id:,
+      msg_id: nil
+    )
+      build("update_push_status") do
+        Requests.update_push_status(analytics_uid, status, device_id, msg_id)
+      end
+    end
+
+    # Cancels a delayed push notification (sent with
+    # send_at). Centrifugo PRO only.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param uid [String, nil] The uid of the push notification to cancel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def cancel_push(uid:)
+      build("cancel_push") do
+        Requests.cancel_push(uid)
+      end
+    end
+
+    # Publishes or updates a key in a map channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The entry key. Required.
+    # @param data [Object, nil] The entry data. In the HTTP API it is any JSON value; over GRPC
+    #   it may be binary.
+    # @param b64data [String, nil] Data as base64, for binary over the HTTP API. Centrifugo
+    #   decodes it.
+    # @param stream_data [Object, nil] Currently not used by the server API.
+    # @param b64stream_data [String, nil] Currently not used by the server API.
+    # @param tags [Hash{String => String}] Key-value metadata attached to the publication.
+    # @param idempotency_key [String, nil] Drops duplicate publications upon retries: a
+    #   publication with a key already used in the channel is not applied
+    #   again, and its result has the first one's position, with suppressed
+    #   set and suppress_reason "idempotency". It acts per channel; keys are
+    #   kept for 5 minutes by default. Every map broker - memory, Redis and
+    #   PostgreSQL - keeps keys.
+    # @param delta [Boolean, nil] Enables delta compression for this publication.
+    # @param version [Integer, nil] A per-key version: publications with a version not higher
+    #   than the key's current one are suppressed.
+    # @param version_epoch [String, nil] Scopes version. A different epoch resets version
+    #   comparison.
+    # @param score [Integer, nil] Currently not used by the server API.
+    # @param key_mode [String, nil] Makes the publish conditional: if_new writes only if the key
+    #   does not exist, if_exists only if it exists. Empty always writes.
+    #   One of: if_new, if_exists.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_publish(
+      channel:,
+      key:,
+      data: nil,
+      b64data: nil,
+      stream_data: nil,
+      b64stream_data: nil,
+      tags: nil,
+      idempotency_key: nil,
+      delta: nil,
+      version: nil,
+      version_epoch: nil,
+      score: nil,
+      key_mode: nil
+    )
+      build("map_publish") do
+        Requests.map_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          stream_data,
+          b64stream_data,
+          tags,
+          idempotency_key,
+          delta,
+          version,
+          version_epoch,
+          score,
+          key_mode
+        )
+      end
+    end
+
+    # Removes a key from a map channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param key [String, nil] The key to remove. Required.
+    # @param idempotency_key [String, nil] Drops duplicate removals upon retries, as it does for
+    #   MapPublishRequest: a removal with a key already used in the channel is
+    #   not applied again, and its result is suppressed with suppress_reason
+    #   "idempotency". Keys are kept for 5 minutes by default.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_remove(channel:, key:, idempotency_key: nil)
+      build("map_remove") do
+        Requests.map_remove(channel, key, idempotency_key)
+      end
+    end
+
+    # Reads the current state of a map channel, with
+    # optional pagination.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param cursor [String, nil] The pagination cursor from the previous page. Empty starts
+    #   from the beginning.
+    # @param limit [Integer, nil] The maximum number of entries per page: -1 means no limit, 0
+    #   returns only the stream position. Page sizes may exceed it with the
+    #   Redis map broker.
+    # @param key [String, nil] Reads a single entry by exact key. cursor and limit are ignored
+    #   when it is set.
+    # @param asc [Boolean, nil] Sorts ordered state by score ascending instead of descending.
+    #   Ignored for unordered channels.
+    # @param revision_offset [Integer, nil] The offset of the position from a previous state
+    #   read, used with revision_epoch.
+    # @param revision_epoch [String, nil] The epoch of the position from a previous state
+    #   read. If the epoch changed, the call fails with an unrecoverable
+    #   position error.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_read_state(
+      channel:,
+      cursor: nil,
+      limit: nil,
+      key: nil,
+      asc: nil,
+      revision_offset: nil,
+      revision_epoch: nil
+    )
+      build("map_read_state") do
+        Requests.map_read_state(
+          channel,
+          cursor,
+          limit,
+          key,
+          asc,
+          revision_offset,
+          revision_epoch
+        )
+      end
+    end
+
+    # Reads the change stream of a map channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @param since_offset [Integer, nil] Returns entries after this offset, used with
+    #   since_epoch.
+    # @param since_epoch [String, nil] The epoch of the since position. It must match the
+    #   current stream epoch.
+    # @param limit [Integer, nil] The maximum number of entries: -1 means no limit, 0 returns
+    #   only the stream position.
+    # @param reverse [Boolean, nil] Returns entries newest first.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_read_stream(
+      channel:,
+      since_offset: nil,
+      since_epoch: nil,
+      limit: nil,
+      reverse: nil
+    )
+      build("map_read_stream") do
+        Requests.map_read_stream(
+          channel,
+          since_offset,
+          since_epoch,
+          limit,
+          reverse
+        )
+      end
+    end
+
+    # Returns statistics about a map channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_stats(channel:)
+      build("map_stats") do
+        Requests.map_stats(channel)
+      end
+    end
+
+    # Removes all state and stream data of a map channel.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the map channel. Required.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def map_clear(channel:)
+      build("map_clear") do
+        Requests.map_clear(channel)
+      end
+    end
+
+    # Pushes data for a key directly to clients of a
+    # shared poll channel, without waiting for the next poll cycle. Requires
+    # versioned mode and publish_enabled on the namespace.
+    #
+    # The command making the call, checked as a Client checks it.
+    #
+    # @param channel [String, nil] The name of the shared poll channel. Required.
+    # @param key [String, nil] The item key. Required.
+    # @param data [Object, nil] The item data, delivered to clients as is.
+    # @param b64data [String, nil] Data as base64, for binary payloads. Centrifugo decodes it.
+    # @param version [Integer, nil] The item version, must be >= 1. Required. A version not
+    #   higher than the current one within the same epoch is silently dropped.
+    # @param epoch [String, nil] The channel-level publisher epoch. A change resets per-key
+    #   versions and unsubscribes current subscribers with insufficient state.
+    # @return [Command]
+    # @raise [InvalidRequestError]
+    def shared_poll_publish(
+      channel:,
+      key:,
+      version:,
+      data: nil,
+      b64data: nil,
+      epoch: nil
+    )
+      build("shared_poll_publish") do
+        Requests.shared_poll_publish(
+          channel,
+          key,
+          data,
+          b64data,
+          version,
+          epoch
+        )
+      end
+    end
+  end
+end