HasNode

Begin querying the model.

Create a new Eloquent query builder for the model.

Get a new query builder for the model's table.

Get a new query builder that doesn't have any global scopes or eager loading.

Get a new query builder with no relationships loaded.

Get a new query builder that doesn't have any global scopes.

Get a new query instance without a given scope.

Get a new query to restore one or more models by their queueable IDs.

Begin querying the model on a given connection.

Begin querying the model on the write connection.

Begin querying a model with eager loading.

Fire the given event for the model, keeping the tree consistent around its observers.

Upstream maintains the tree from listeners registered in bootNodeTrait(). A custom $dispatchesEvents result skips those listeners, and listeners cannot act after every deleting observer has allowed a delete, so the maintenance runs here instead.

Set an action.

Call pending action.

Save the model to the database.

Save the model to the database, ignoring specific unique constraint conflicts.

Run a save, restoring its consumed action when the save does not complete.

Determine whether the model uses soft deletes.

Apply a raw node action.

Resolve the deferred parent and append the node to it.

Make a root node.

Save the node as a root without moving an existing root.

Get the lower bound.

Append or prepend a node to the parent.

Append or prepend using a parent already read from the write connection.

Apply parent model.

Apply the current parent of a sibling without resolving its relation.

Insert node before or after another node.

Refresh node's crucial attributes.

Prepare a model to participate in a structural mutation.

Prepare an existing model for a structural mutation from its persisted row.

Apply an authoritative structural snapshot to this model.

Read selected attributes from the exact persisted row.

Read selected attributes from the exact persisted row, if it still exists.

Get the columns that define structural position.

Get the columns that identify one mutable tree row.

Relation to the parent.

Relation to children.

Get query for descendants of the node.

Get query for siblings of the node.

Get the relation for the node siblings and the node itself.

Get the node siblings and the node itself.

Get query for siblings after the node.

Get query for siblings before the node.

Get query for nodes after current node.

Get query for nodes before current node.

Get query ancestors of the node.

Make this node a root node.

Save node as root.

Append and save a node.

Prepend and save a node.

Append a node to the new parent.

Prepend a node to the new parent.

Prepare the node for insertion as a child.

Insert self after a node.

Insert self before node.

Prepare the node for insertion beside another node.

Insert self after a node and save.

Insert self before a node and save.

Set raw structural values.

Move node up given amount of positions.

Move node down given amount of positions.

Insert node at specific position.

Move a node to the new position.

Insert new node at specified position.

Delete the node's descendants, including any hidden by ordinary global scopes.

Hard deletes run before the node's own row is deleted and soft deletes after it, so descendants are never trashed before the node.

Determine whether descendant model events should be fired during deletion and restoration.

Get the number of descendants loaded per evented deletion or restoration chunk.

Delete descendants through their model lifecycle in children-first chunks.

Change descendants one at a time in bounded chunks ordered by their left bound.

Restore descendants deleted at or after the given stored deletion time.

Get a new base query that includes deleted nodes.

Get a new query with ordinary visibility and the concrete tree scope.

Apply the concrete tree scope to the query.

Get the attributes that partition nested set trees.

Determine whether every configured scope attribute is loaded.

Ensure an existing model has not changed tree scope.

Ensure a model selects one concrete nested set scope.

Get the normalized scope values for this tree.

Normalize a nested set scope value for SQL and identity comparisons.

Get the stable identity key for this tree scope.

Begin a query for one concrete nested set scope.

Create a new nested set collection.

Use children key on $attributes to create child nodes.

Get node height (rgt - lft + 1).

Get number of descendant nodes.

Set the value of model's parent id key.

Behind the scenes node is appended to found parent node.

Get whether node is root.

Determine whether the node is a leaf.

Get the lft key name.

Get the rgt key name.

Get the parent id key name.

Get the depth column name.

Get the value of the model's lft key.

Get the value of the model's rgt key.

Get the value of the model's parent id key.

Get the node depth.

Return the node that is next to the current node without constraining to siblings.

This can be either a next sibling or a next sibling of the parent node.

Return the node that is before the current node without constraining to siblings.

This can be either a prev sibling or parent node.

Get the node's ancestors.

Get the node's descendants.

Get the node's siblings.

Get siblings after the node.

Get siblings before the node.

Get the next sibling.

Get the previous sibling.

Get whether a node is a descendant of other node.

Get whether a node is itself or a descendant of other node.

Get whether the node is immediate children of other node.

Get whether the node is a sibling of another node.

Get whether the node is an ancestor of other node, including immediate parent.

Get whether the node is itself or an ancestor of other node, including immediate parent.

Get whether the node has moved since last save.

Get whether user is intended to delete the model from database entirely.

Get the node bounds.

Set the left bound.

Set the right bound.

Set the parent key.

Set the node depth.

Mark the stored bounds as dirty.

Forget relations derived from the node's structural position.

Reject structural targets that are already known to be unusable.

Partial models are deliberately allowed here. The save boundary reloads every participant from the write connection before changing the tree.

Assert that a node is neither this node nor one of its descendants.

Assert that a node has positive tree bounds.

Ensure that this node has loaded bounds.

Ensure that this node has loaded parentage.

Ensure that this node has loaded scope attributes.

Ensure that a node belongs to the same nested set tree.

Determine whether a node belongs to the same concrete scope.

Determine whether the models address the same nested set tree.

Determine whether the models address the same persisted row.

Clone the node without structural attributes.