docs: def counter(self, key, delta=1, initial=None, ttl=0):
          """Increment or decrement the numeric value of an item.
  
          This method instructs the server to treat the item stored under
          the given key as a numeric counter.
  
          Counter operations require that the stored value
          exists as a string representation of a number (e.g. ``123``). If
          storing items using the :meth:`upsert` family of methods, and
          using the default :const:`couchbase.FMT_JSON` then the value
          will conform to this constraint.
  
          :param string key: A key whose counter value is to be modified
          :param int delta: an amount by which the key should be modified.
              If the number is negative then this number will be
              *subtracted* from the current value.
          :param initial: The initial value for the key, if it does not
              exist. If the key does not exist, this value is used, and
              `delta` is ignored. If this parameter is `None` then no
              initial value is used
          :type initial: int or `None`
          :param int ttl: The lifetime for the key, after which it will
              expire
          :raise: :exc:`.NotFoundError` if the key does not exist on the
              bucket (and `initial` was `None`)
          :raise: :exc:`.DeltaBadvalError` if the key exists, but the
              existing value is not numeric
          :return: A :class:`.Result` object. The current value of the
              counter may be obtained by inspecting the return value's
              `value` attribute.
  
          Simple increment::
  
              rv = cb.counter("key")
              rv.value
              # 42
  
          Increment by 10::
  
              rv = cb.counter("key", delta=10)
  
          Decrement by 5::
  
              rv = cb.counter("key", delta=-5)
  
          Increment by 20, set initial value to 5 if it does not exist::
  
              rv = cb.counter("key", delta=20, initial=5)
  
          Increment three keys::
  
              kv = cb.counter_multi(["foo", "bar", "baz"])
              for key, result in kv.items():
                  print "Key %s has value %d now" % (key, result.value)
  
          .. seealso:: :meth:`counter_multi`
          """
          return _Base.counter(self, key, delta=delta, initial=initial, ttl=ttl)