docs: def remove(self, key, cas=0, quiet=None, persist_to=0, replicate_to=0):
          """Remove the key-value entry for a given key in Couchbase.
  
          :param key: A string which is the key to remove. The format and
              type of the key follows the same conventions as in
              :meth:`upsert`
          :type key: string, dict, or tuple/list
  
          :param int cas: The CAS to use for the removal operation.
              If specified, the key will only be removed from the server
              if it has the same CAS as specified. This is useful to
              remove a key only if its value has not been changed from the
              version currently visible to the client. If the CAS on the
              server does not match the one specified, an exception is
              thrown.
          :param boolean quiet:
              Follows the same semantics as `quiet` in :meth:`get`
          :param int persist_to: If set, wait for the item to be removed
              from the storage of at least these many nodes
          :param int replicate_to: If set, wait for the item to be removed
              from the cache of at least these many nodes
              (excluding the master)
          :raise: :exc:`.NotFoundError` if the key does not exist.
          :raise: :exc:`.KeyExistsError` if a CAS was specified, but
              the CAS on the server had changed
          :return: A :class:`~.Result` object.
  
          Simple remove::
  
              ok = cb.remove("key").success
  
          Don't complain if key does not exist::
  
              ok = cb.remove("key", quiet=True)
  
          Only remove if CAS matches our version::
  
              rv = cb.get("key")
              cb.remove("key", cas=rv.cas)
  
          Remove multiple keys::
  
              oks = cb.remove_multi(["key1", "key2", "key3"])
  
          Remove multiple keys with CAS::
  
              oks = cb.remove({
                  "key1" : cas1,
                  "key2" : cas2,
                  "key3" : cas3
              })
  
          .. seealso:: :meth:`remove_multi`, :meth:`endure`
              for more information on the ``persist_to`` and
              ``replicate_to`` options.
          """
          return _Base.remove(self, key, cas=cas, quiet=quiet,
                              persist_to=persist_to, replicate_to=replicate_to)