docs: function SlackRtmIn(n) {
      RED.nodes.createNode(this, n);
  
      var node = this;
      this.client = n.client;
      this.events = n.events;
      this.clientNode = RED.nodes.getNode(this.client);
  
      var eventNames;
      if (this.events) {
        eventNames = this.events
          .replace(/[\s]+/g, "")
          .split(",")
          .filter(Boolean);
      }
  
      node.status(statuses.disconnected);
  
      if (node.client) {
        SetConfigNodeConnectionListeners(node);
  
        node.clientNode.rtmClient.on("slack_event", (eventType, event) => {
          /**
           * responses to websocket commands come over the without an eventType
           */
          if (eventType === undefined) {
            eventType = "ws_response";
            event.type = eventType;
          }
  
          /**
           * ignore non-subscribed events
           * 
           * Since the message events are bound to the same object as connection
           * events this feature has been implemented in this fashion vs directly
           * subscribing to prevent stupid (ie: someone setting a value of
           * 'connected' or the like) in node properties. Crude but effective.
           * 
           * It also decouples the feature from the semantics of the client.
           */
          if (this.events && eventNames.length > 0) {
            if (
              !(
                eventNames.includes(event.type) ||
                (event.subtype &&
                  eventNames.includes(`${event.type}::${event.subtype}`))
              )
            ) {
              return null;
            }
          }
  
          /**
           * pong: triggered in response to a ping keep-alive
           *
           * hello: triggered on connect
           *
           * ws_response: triggered after data has been sent over the ws
           *
           * channel_marked: triggered when the bot user has 'read' a channel
           *
           * desktop_notification: triggered when the bot user is @mentioned or
           * otherwise would receive an alert
           *
           * pretty sure nobody is interested in the below
           * note that ws_response is sent on the output side of the output node
           * so receiving it here is double processing
           */
          if (eventType == "pong" || eventType == "ws_response") {
            return null;
          }
  
          SlackDebug("slack-rtm-in incoming event", event);
          var msg = {};
          msg.payload = node.clientNode.dressResponseMessage(event);
          msg.slackState = node.clientNode.state;
          node.send(msg);
        });
      } else {
        node.status(statuses.misconfigured);
      }
    }