delete a variable from the rooms data object

@param {String} roomID id for the room
@param {String} key variable name/key that you want to delete
@return {Promise} once this promise succeeds it will return the value that was stored before delete
194903
function( roomID, key ) {

		var oldVal;

		if( roomData[ roomID ] === undefined ) {

			return promise.reject( 'There is no room by that id' );
		} else {

			oldVal = roomData[ roomID ][ key ];

			delete roomData[ roomID ][ key ];

			return promise.resolve( oldVal );
		}
	}
524937
function( key ) {

		var savedRoomId = keyToId[ key ];

		if( savedRoomId ) {

			return promise.resolve( savedRoomId );
		} else {

			return promise.reject();
		}
	}
36735
function sendToRoom(content, room) {
    return getRoomId(room)
        .then((roomId) => sendToRoomId(content, roomId));
}
331489
@Override
    public V remove(Object key) {
        CachedValue<K, V> entry = map.remove(key);
        if (entry != null) {
            onValueRemove(entry);
            if (!isValueExpired(entry)) {
                return (V) entry.getValue();
            }
        }
        return null;
    }
1301212
function( userId, id ) {

		return this.memory.joinRoom( userId, id )
		.then( function( id ) {

			if( rooms[ id ] === undefined ) {

				rooms[ id ] = room( this.memory, id );	
			}
			
			return promise.resolve( rooms[ id ] );
		}.bind( this ));
	}
147152
function _remove(key) {
    var i = _keys.indexOf(key)
    if (i > -1) {
      ls.removeItem(key);
      _keys.splice(_keys.indexOf(key), 1);
      delete _config[key];
    }
  }
290719
function delExpiry(key, req) {
  var rval = this.getRawKey(key);
  if(rval === undefined || rval.e === undefined) return 0;
  // the code flow ensures we have a valid
  // index into the expiring keys array
  this._ekeys.splice(ArrayIndex.indexOf(key, this._ekeys), 1);
  delete this._expires[key];
  delete rval.e;
  return 1;
}
77845
def channels_delete(self, room_id=None, channel=None, **kwargs):
        """"""
        if room_id:
            return self.__call_api_post('channels.delete', roomId=room_id, kwargs=kwargs)
        elif channel:
            return self.__call_api_post('channels.delete', roomName=channel, kwargs=kwargs)
        else:
            raise RocketMissingParamException('roomId or channel required')
463399
function hashDelete$1(key) {
  var result = this.has(key) && delete this.__data__[key];
  this.size -= result ? 1 : 0;
  return result;
}
508826
public ResponseWrapper removeChatRoomMembers(long roomId, Members members)
            throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(roomId > 0, "room id is invalid");
        Preconditions.checkArgument(members != null, "members should not be empty");
        return _httpClient.sendDelete(_baseUrl + mChatRoomPath + "/" + roomId + "/members", members.toString());
    }
714333
function del (obj, key) {
  var ob = obj.__ob__;
  if (obj._isVue || (ob && ob.vmCount)) {
    process.env.NODE_ENV !== 'production' && warn(
      'Avoid deleting properties on a Vue instance or its root $data ' +
      '- just set it to null.'
    );
    return
  }
  if (!hasOwn(obj, key)) {
    return
  }
  delete obj[key];
  if (!ob) {
    return
  }
  ob.dep.notify();
}
1256752
function SessionStorage_remove(key) {
        var nKey = this.config.key_prefix + key,
            tKey = nKey + '_TIME';
        // clear old timeout to avoid memory leak
        if (this.timeouts.hasOwnProperty(tKey)) {
            clearTimeout(this.timeouts[tKey]);
            // remove old time key
            delete this.timeouts[tKey];
        }
        return this.config.storage.remove(nKey);
    }
361922
function(id, key) {
      // if key is defined and of type string....
      if(typeof key !== 'undefined' && typeof key === 'string') {

        // if id/key exists...
        if(memStore[id] && memStore[id][key]) {
          delete memStore[id][key];
        }

        return true;
      }

      // else if key is not defined...
      else if(typeof key === 'undefined') {
        delete memStore[id];
        return true;
      }

      // else key defined, but not of type string...
      else {
        throw new Error('invalid data type or missing value');
        return false;
      }
    }
1162977
function del(key, cb) {
  return type(key) != 'array'
    ? localForage.removeItem(key).then(wrap(cb), cb)
    : Promise.all(key.map(del)).then(wrap(cb), cb);
}
298908
public ResponseWrapper deleteChatRoom(long roomId) throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(roomId > 0, "room id is invalid");
        return _httpClient.sendDelete(_baseUrl + mChatRoomPath + "/" + roomId);
    }
707240
@Override
  public void deleteRow(K key) {
    createMutator().delete(key, getColumnFamily(), null, null);
  }
461099
function leaveRoom(room) {
    return __awaiter(this, void 0, void 0, function* () {
        let roomId = yield getRoomId(room);
        let joinedIndex = exports.joinedIds.indexOf(room);
        if (joinedIndex === -1) {
            log_1.logger.error(`[leaveRoom] failed because bot has not joined ${room}`);
        }
        else {
            yield asyncCall('leaveRoom', roomId);
            delete exports.joinedIds[joinedIndex];
        }
    });
}