@bitrix24/b24jssdk/dist/esm/pullClient/protobuf/model.mjs

Bitrix24 REST API JavaScript SDK

/**
 * @package @bitrix24/b24jssdk
 * @version 1.0.1
 * @copyright (c) 2026 Bitrix24
 * @license MIT
 * @see https://github.com/bitrix24/b24jssdk
 * @see https://bitrix24.github.io/b24jssdk/
 */
import $protobuf from '../../_virtual/protobuf.mjs';

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
let $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
const $root = $protobuf.roots["push-server"] || ($protobuf.roots["push-server"] = {});
$root.RequestBatch = (function() {
  function RequestBatch(properties) {
    this.requests = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(RequestBatch, "RequestBatch");
  RequestBatch.prototype.requests = $util.emptyArray;
  RequestBatch.create = /* @__PURE__ */ __name(function create(properties) {
    return new RequestBatch(properties);
  }, "create");
  RequestBatch.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.requests != null && message.requests.length) {
      for (var i = 0; i < message.requests.length; ++i)
        $root.Request.encode(
          message.requests[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  RequestBatch.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.RequestBatch();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.requests && message.requests.length)) {
            message.requests = [];
          }
          message.requests.push($root.Request.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return RequestBatch;
})();
$root.Request = (function() {
  function Request(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(Request, "Request");
  Request.prototype.incomingMessages = null;
  Request.prototype.channelStats = null;
  Request.prototype.serverStats = null;
  var $oneOfFields;
  Object.defineProperty(Request.prototype, "command", {
    get: $util.oneOfGetter(
      $oneOfFields = ["incomingMessages", "channelStats", "serverStats"]
    ),
    set: $util.oneOfSetter($oneOfFields)
  });
  Request.create = /* @__PURE__ */ __name(function create(properties) {
    return new Request(properties);
  }, "create");
  Request.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.incomingMessages != null && message.hasOwnProperty("incomingMessages")) {
      $root.IncomingMessagesRequest.encode(
        message.incomingMessages,
        writer.uint32(
          /* id 1, wireType 2 =*/
          10
        ).fork()
      ).ldelim();
    }
    if (message.channelStats != null && message.hasOwnProperty("channelStats")) {
      $root.ChannelStatsRequest.encode(
        message.channelStats,
        writer.uint32(
          /* id 2, wireType 2 =*/
          18
        ).fork()
      ).ldelim();
    }
    if (message.serverStats != null && message.hasOwnProperty("serverStats")) {
      $root.ServerStatsRequest.encode(
        message.serverStats,
        writer.uint32(
          /* id 3, wireType 2 =*/
          26
        ).fork()
      ).ldelim();
    }
    return writer;
  }, "encode");
  Request.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Request();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.incomingMessages = $root.IncomingMessagesRequest.decode(
            reader,
            reader.uint32()
          );
          break;
        case 2:
          message.channelStats = $root.ChannelStatsRequest.decode(
            reader,
            reader.uint32()
          );
          break;
        case 3:
          message.serverStats = $root.ServerStatsRequest.decode(
            reader,
            reader.uint32()
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return Request;
})();
$root.IncomingMessagesRequest = (function() {
  function IncomingMessagesRequest(properties) {
    this.messages = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(IncomingMessagesRequest, "IncomingMessagesRequest");
  IncomingMessagesRequest.prototype.messages = $util.emptyArray;
  IncomingMessagesRequest.create = /* @__PURE__ */ __name(function create(properties) {
    return new IncomingMessagesRequest(properties);
  }, "create");
  IncomingMessagesRequest.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.messages != null && message.messages.length) {
      for (var i = 0; i < message.messages.length; ++i)
        $root.IncomingMessage.encode(
          message.messages[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  IncomingMessagesRequest.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.IncomingMessagesRequest();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.messages && message.messages.length)) {
            message.messages = [];
          }
          message.messages.push(
            $root.IncomingMessage.decode(reader, reader.uint32())
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return IncomingMessagesRequest;
})();
$root.IncomingMessage = (function() {
  function IncomingMessage(properties) {
    this.receivers = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(IncomingMessage, "IncomingMessage");
  IncomingMessage.prototype.receivers = $util.emptyArray;
  IncomingMessage.prototype.sender = null;
  IncomingMessage.prototype.body = "";
  IncomingMessage.prototype.expiry = 0;
  IncomingMessage.prototype.type = "";
  IncomingMessage.create = /* @__PURE__ */ __name(function create(properties) {
    return new IncomingMessage(properties);
  }, "create");
  IncomingMessage.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.receivers != null && message.receivers.length) {
      for (var i = 0; i < message.receivers.length; ++i)
        $root.Receiver.encode(
          message.receivers[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    if (message.sender != null && message.hasOwnProperty("sender")) {
      $root.Sender.encode(
        message.sender,
        writer.uint32(
          /* id 2, wireType 2 =*/
          18
        ).fork()
      ).ldelim();
    }
    if (message.body != null && message.hasOwnProperty("body")) {
      writer.uint32(
        /* id 3, wireType 2 =*/
        26
      ).string(message.body);
    }
    if (message.expiry != null && message.hasOwnProperty("expiry")) {
      writer.uint32(
        /* id 4, wireType 0 =*/
        32
      ).uint32(message.expiry);
    }
    if (message.type != null && message.hasOwnProperty("type")) {
      writer.uint32(
        /* id 5, wireType 2 =*/
        42
      ).string(message.type);
    }
    return writer;
  }, "encode");
  IncomingMessage.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.IncomingMessage();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.receivers && message.receivers.length)) {
            message.receivers = [];
          }
          message.receivers.push($root.Receiver.decode(reader, reader.uint32()));
          break;
        case 2:
          message.sender = $root.Sender.decode(reader, reader.uint32());
          break;
        case 3:
          message.body = reader.string();
          break;
        case 4:
          message.expiry = reader.uint32();
          break;
        case 5:
          message.type = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return IncomingMessage;
})();
$root.ChannelStatsRequest = (function() {
  function ChannelStatsRequest(properties) {
    this.channels = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ChannelStatsRequest, "ChannelStatsRequest");
  ChannelStatsRequest.prototype.channels = $util.emptyArray;
  ChannelStatsRequest.create = /* @__PURE__ */ __name(function create(properties) {
    return new ChannelStatsRequest(properties);
  }, "create");
  ChannelStatsRequest.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.channels != null && message.channels.length) {
      for (var i = 0; i < message.channels.length; ++i)
        $root.ChannelId.encode(
          message.channels[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  ChannelStatsRequest.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ChannelStatsRequest();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.channels && message.channels.length)) {
            message.channels = [];
          }
          message.channels.push($root.ChannelId.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ChannelStatsRequest;
})();
$root.ChannelId = (function() {
  function ChannelId(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ChannelId, "ChannelId");
  ChannelId.prototype.id = $util.newBuffer([]);
  ChannelId.prototype.isPrivate = false;
  ChannelId.prototype.signature = $util.newBuffer([]);
  ChannelId.create = /* @__PURE__ */ __name(function create(properties) {
    return new ChannelId(properties);
  }, "create");
  ChannelId.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.id != null && message.hasOwnProperty("id")) {
      writer.uint32(
        /* id 1, wireType 2 =*/
        10
      ).bytes(message.id);
    }
    if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) {
      writer.uint32(
        /* id 2, wireType 0 =*/
        16
      ).bool(message.isPrivate);
    }
    if (message.signature != null && message.hasOwnProperty("signature")) {
      writer.uint32(
        /* id 3, wireType 2 =*/
        26
      ).bytes(message.signature);
    }
    return writer;
  }, "encode");
  ChannelId.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ChannelId();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.bytes();
          break;
        case 2:
          message.isPrivate = reader.bool();
          break;
        case 3:
          message.signature = reader.bytes();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ChannelId;
})();
$root.ServerStatsRequest = (function() {
  function ServerStatsRequest(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ServerStatsRequest, "ServerStatsRequest");
  ServerStatsRequest.create = /* @__PURE__ */ __name(function create(properties) {
    return new ServerStatsRequest(properties);
  }, "create");
  ServerStatsRequest.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    return writer;
  }, "encode");
  ServerStatsRequest.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ServerStatsRequest();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ServerStatsRequest;
})();
$root.Sender = (function() {
  function Sender(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(Sender, "Sender");
  Sender.prototype.type = 0;
  Sender.prototype.id = $util.newBuffer([]);
  Sender.create = /* @__PURE__ */ __name(function create(properties) {
    return new Sender(properties);
  }, "create");
  Sender.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.type != null && message.hasOwnProperty("type")) {
      writer.uint32(
        /* id 1, wireType 0 =*/
        8
      ).int32(message.type);
    }
    if (message.id != null && message.hasOwnProperty("id")) {
      writer.uint32(
        /* id 2, wireType 2 =*/
        18
      ).bytes(message.id);
    }
    return writer;
  }, "encode");
  Sender.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Sender();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.type = reader.int32();
          break;
        case 2:
          message.id = reader.bytes();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return Sender;
})();
$root.SenderType = (function() {
  var valuesById = {}, values = Object.create(valuesById);
  values[valuesById[0] = "UNKNOWN"] = 0;
  values[valuesById[1] = "CLIENT"] = 1;
  values[valuesById[2] = "BACKEND"] = 2;
  return values;
})();
$root.Receiver = (function() {
  function Receiver(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(Receiver, "Receiver");
  Receiver.prototype.id = $util.newBuffer([]);
  Receiver.prototype.isPrivate = false;
  Receiver.prototype.signature = $util.newBuffer([]);
  Receiver.create = /* @__PURE__ */ __name(function create(properties) {
    return new Receiver(properties);
  }, "create");
  Receiver.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.id != null && message.hasOwnProperty("id")) {
      writer.uint32(
        /* id 1, wireType 2 =*/
        10
      ).bytes(message.id);
    }
    if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) {
      writer.uint32(
        /* id 2, wireType 0 =*/
        16
      ).bool(message.isPrivate);
    }
    if (message.signature != null && message.hasOwnProperty("signature")) {
      writer.uint32(
        /* id 3, wireType 2 =*/
        26
      ).bytes(message.signature);
    }
    return writer;
  }, "encode");
  Receiver.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Receiver();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.bytes();
          break;
        case 2:
          message.isPrivate = reader.bool();
          break;
        case 3:
          message.signature = reader.bytes();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return Receiver;
})();
$root.ResponseBatch = (function() {
  function ResponseBatch(properties) {
    this.responses = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ResponseBatch, "ResponseBatch");
  ResponseBatch.prototype.responses = $util.emptyArray;
  ResponseBatch.create = /* @__PURE__ */ __name(function create(properties) {
    return new ResponseBatch(properties);
  }, "create");
  ResponseBatch.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.responses != null && message.responses.length) {
      for (var i = 0; i < message.responses.length; ++i)
        $root.Response.encode(
          message.responses[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  ResponseBatch.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ResponseBatch();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.responses && message.responses.length)) {
            message.responses = [];
          }
          message.responses.push($root.Response.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ResponseBatch;
})();
$root.Response = (function() {
  function Response(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(Response, "Response");
  Response.prototype.outgoingMessages = null;
  Response.prototype.channelStats = null;
  Response.prototype.serverStats = null;
  var $oneOfFields;
  Object.defineProperty(Response.prototype, "command", {
    get: $util.oneOfGetter(
      $oneOfFields = ["outgoingMessages", "channelStats", "serverStats"]
    ),
    set: $util.oneOfSetter($oneOfFields)
  });
  Response.create = /* @__PURE__ */ __name(function create(properties) {
    return new Response(properties);
  }, "create");
  Response.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.outgoingMessages != null && message.hasOwnProperty("outgoingMessages")) {
      $root.OutgoingMessagesResponse.encode(
        message.outgoingMessages,
        writer.uint32(
          /* id 1, wireType 2 =*/
          10
        ).fork()
      ).ldelim();
    }
    if (message.channelStats != null && message.hasOwnProperty("channelStats")) {
      $root.ChannelStatsResponse.encode(
        message.channelStats,
        writer.uint32(
          /* id 2, wireType 2 =*/
          18
        ).fork()
      ).ldelim();
    }
    if (message.serverStats != null && message.hasOwnProperty("serverStats")) {
      $root.JsonResponse.encode(
        message.serverStats,
        writer.uint32(
          /* id 3, wireType 2 =*/
          26
        ).fork()
      ).ldelim();
    }
    return writer;
  }, "encode");
  Response.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.Response();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.outgoingMessages = $root.OutgoingMessagesResponse.decode(
            reader,
            reader.uint32()
          );
          break;
        case 2:
          message.channelStats = $root.ChannelStatsResponse.decode(
            reader,
            reader.uint32()
          );
          break;
        case 3:
          message.serverStats = $root.JsonResponse.decode(
            reader,
            reader.uint32()
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return Response;
})();
$root.OutgoingMessagesResponse = (function() {
  function OutgoingMessagesResponse(properties) {
    this.messages = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(OutgoingMessagesResponse, "OutgoingMessagesResponse");
  OutgoingMessagesResponse.prototype.messages = $util.emptyArray;
  OutgoingMessagesResponse.create = /* @__PURE__ */ __name(function create(properties) {
    return new OutgoingMessagesResponse(properties);
  }, "create");
  OutgoingMessagesResponse.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.messages != null && message.messages.length) {
      for (var i = 0; i < message.messages.length; ++i)
        $root.OutgoingMessage.encode(
          message.messages[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  OutgoingMessagesResponse.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.OutgoingMessagesResponse();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.messages && message.messages.length)) {
            message.messages = [];
          }
          message.messages.push(
            $root.OutgoingMessage.decode(reader, reader.uint32())
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return OutgoingMessagesResponse;
})();
$root.OutgoingMessage = (function() {
  function OutgoingMessage(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(OutgoingMessage, "OutgoingMessage");
  OutgoingMessage.prototype.id = $util.newBuffer([]);
  OutgoingMessage.prototype.body = "";
  OutgoingMessage.prototype.expiry = 0;
  OutgoingMessage.prototype.created = 0;
  OutgoingMessage.prototype.sender = null;
  OutgoingMessage.create = /* @__PURE__ */ __name(function create(properties) {
    return new OutgoingMessage(properties);
  }, "create");
  OutgoingMessage.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.id != null && message.hasOwnProperty("id")) {
      writer.uint32(
        /* id 1, wireType 2 =*/
        10
      ).bytes(message.id);
    }
    if (message.body != null && message.hasOwnProperty("body")) {
      writer.uint32(
        /* id 2, wireType 2 =*/
        18
      ).string(message.body);
    }
    if (message.expiry != null && message.hasOwnProperty("expiry")) {
      writer.uint32(
        /* id 3, wireType 0 =*/
        24
      ).uint32(message.expiry);
    }
    if (message.created != null && message.hasOwnProperty("created")) {
      writer.uint32(
        /* id 4, wireType 5 =*/
        37
      ).fixed32(message.created);
    }
    if (message.sender != null && message.hasOwnProperty("sender")) {
      $root.Sender.encode(
        message.sender,
        writer.uint32(
          /* id 5, wireType 2 =*/
          42
        ).fork()
      ).ldelim();
    }
    return writer;
  }, "encode");
  OutgoingMessage.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.OutgoingMessage();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.bytes();
          break;
        case 2:
          message.body = reader.string();
          break;
        case 3:
          message.expiry = reader.uint32();
          break;
        case 4:
          message.created = reader.fixed32();
          break;
        case 5:
          message.sender = $root.Sender.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return OutgoingMessage;
})();
$root.ChannelStatsResponse = (function() {
  function ChannelStatsResponse(properties) {
    this.channels = [];
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ChannelStatsResponse, "ChannelStatsResponse");
  ChannelStatsResponse.prototype.channels = $util.emptyArray;
  ChannelStatsResponse.create = /* @__PURE__ */ __name(function create(properties) {
    return new ChannelStatsResponse(properties);
  }, "create");
  ChannelStatsResponse.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.channels != null && message.channels.length) {
      for (var i = 0; i < message.channels.length; ++i)
        $root.ChannelStats.encode(
          message.channels[i],
          writer.uint32(
            /* id 1, wireType 2 =*/
            10
          ).fork()
        ).ldelim();
    }
    return writer;
  }, "encode");
  ChannelStatsResponse.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ChannelStatsResponse();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (!(message.channels && message.channels.length)) {
            message.channels = [];
          }
          message.channels.push(
            $root.ChannelStats.decode(reader, reader.uint32())
          );
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ChannelStatsResponse;
})();
$root.ChannelStats = (function() {
  function ChannelStats(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(ChannelStats, "ChannelStats");
  ChannelStats.prototype.id = $util.newBuffer([]);
  ChannelStats.prototype.isPrivate = false;
  ChannelStats.prototype.isOnline = false;
  ChannelStats.create = /* @__PURE__ */ __name(function create(properties) {
    return new ChannelStats(properties);
  }, "create");
  ChannelStats.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.id != null && message.hasOwnProperty("id")) {
      writer.uint32(
        /* id 1, wireType 2 =*/
        10
      ).bytes(message.id);
    }
    if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) {
      writer.uint32(
        /* id 2, wireType 0 =*/
        16
      ).bool(message.isPrivate);
    }
    if (message.isOnline != null && message.hasOwnProperty("isOnline")) {
      writer.uint32(
        /* id 3, wireType 0 =*/
        24
      ).bool(message.isOnline);
    }
    return writer;
  }, "encode");
  ChannelStats.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.ChannelStats();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.id = reader.bytes();
          break;
        case 2:
          message.isPrivate = reader.bool();
          break;
        case 3:
          message.isOnline = reader.bool();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return ChannelStats;
})();
$root.JsonResponse = (function() {
  function JsonResponse(properties) {
    if (properties) {
      for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
        if (properties[keys[i]] != null) {
          this[keys[i]] = properties[keys[i]];
        }
    }
  }
  __name(JsonResponse, "JsonResponse");
  JsonResponse.prototype.json = "";
  JsonResponse.create = /* @__PURE__ */ __name(function create(properties) {
    return new JsonResponse(properties);
  }, "create");
  JsonResponse.encode = /* @__PURE__ */ __name(function encode(message, writer) {
    if (!writer) {
      writer = $Writer.create();
    }
    if (message.json != null && message.hasOwnProperty("json")) {
      writer.uint32(
        /* id 1, wireType 2 =*/
        10
      ).string(message.json);
    }
    return writer;
  }, "encode");
  JsonResponse.decode = /* @__PURE__ */ __name(function decode(reader, length) {
    if (!(reader instanceof $Reader)) {
      reader = $Reader.create(reader);
    }
    var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.JsonResponse();
    while (reader.pos < end) {
      var tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.json = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }, "decode");
  return JsonResponse;
})();

export { $root };
//# sourceMappingURL=model.mjs.map