Undocumented function

Can be forced to work multiple times, otherwise there's a lock.

@return self
770680
public function rewire($force=false): self
    {
        if(!$force && $this->rewired)
            return $this;

        Hooks::setup($this);

        $this->on("modified", [$this, "persist"]);
        $this->on("edge.created", [$this, "onEdgeCreated"]);
        $this->on("edge.connected", [$this, "onEdgeConnected"]);
        $this->on("deleting", [$this, "onDeleting"]);

        $this->rewired = true;
        return $this;
    }
1263800
public function refresh() : self {
      $string = $this->assemble();
      $this->cleanCollection();

      $tokens = Helper::getTokensFromString($string);
      $this->setItems($tokens);

      $this->rewind();
      return $this;
    }
593438
protected function createLockObject()
    {
        $this->checkLockFactory();

        if (null === $this->lock && null !== $this->lockFactory) {
            $ttl = 30;

            $this->lock = $this->lockFactory
                ->createLock($this->lockKey(), $ttl);
        }

        return $this->lock;
    }
6961
public function immutable()
    {
        $this->isImmutable = true;

        // Lock nested items.
        foreach ($this->getArrayCopy() as $item) {
            if ($item instanceof MultiValue) {
                $item->immutable();
            }
        }
        return $this;
    }
1211959
public function reset()
    {
        $this->builder->resetQueryParts();
        $this->relations = [];
        $this->resetBinds();

        $this->setQuery();
        $this->values();
        $this->setPrimaryKeyConditions();

        return $this;
    }
1270243
public function __unsetHook()
    {
        return function ($next, $value, $args) {
            $key = $args->get('key');

            if ($this->hasMapping($key)) {
                return $this->forget($key);
            }

            return $next($value, $args);
        };
    }
1173151
public function reset()
    {
        $this->argumentsAccessor = new ArrayAccessor($this->persistedArguments);
        $this->stateChanged = false;
        return $this;
    }
1110099
public function reset()
    {
        $this->file = null;
        $this->extend = null;
        $this->parent = null;
        $this->data = null;
        $this->block = [];
        $this->blockQueue = null;
        $this->currentBlock = null;

        return $this;
    }
1139794
public function removeLast(): self
    {
        $tmpArray = $this->getArray();

        \array_pop($tmpArray);

        return static::create(
            $tmpArray,
            $this->iteratorClass,
            false
        );
    }
1147516
public function negate() : self
    {
        $b = [];

        foreach ($this->a as $value) {
            $b[] = -$value;
        }

        return static::quick($b);
    }
140672
public function reset()
    {
        $this->header = null;
        $this->line   = 0;
        $this->file->rewind();

        return $this;
    }
322600
function undo() {
		if ($this->flag) {
			if ($this->count)
				$this->count--;
			return $this->restore($this->count);
		}
		return $this;
	}
181132
protected function __tryLock()
    {
        return PoolManager::use($this->poolName, function($resource, $redis){
            return 1 == $redis->evalEx(<<<SCRIPT
local key     = KEYS[1]
local content = KEYS[2]
local ttl     = ARGV[2]
local db      = ARGV[1]
redis.call('select', db)
local lockSet = redis.call('setnx', key, content)
if lockSet == 1 then
redis.call('pexpire', key, ttl)
else 
local value = redis.call('get', key)
if(value == content) then
lockSet = 1;
redis.call('pexpire', key, ttl)
end
end
return lockSet
SCRIPT
            , [
                $this->key,
                $this->guid,
                $this->db,
                $this->lockExpire,
            ], 2);
        });
    }
132746
public function again()
    {
        $this->next = $this->current->map(function ($item) {
            return $item->toArray();
        })->merge($this->next)->toArray();

        $this->session->keep([$this->key]);
    }
194311
public function uncork()
    {
        $this->_corked = false;

        while ($call = array_shift($this->_queue)) {
            call_user_func_array(array($this,'trigger'), $call);
        }

        return $this;
    }
478414
public function duplicate()
    {
        if (false === $this->is_duplicated) {
            $this->_duplicate();
            $this->is_duplicated = true;
            $this->node = parent::getNode();
        }
        return $this;
    }
202940
public function remove(): self
    {
        if ($this->_parent) {
            $id = spl_object_hash($this);
            unset($this->_parent->_children[$id]);
            unset($this->_parent);
        }
        return $this;
    }