Storyden

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/Southclaws/lexorank"
	"github.com/Southclaws/storyden/internal/ent/account"
	"github.com/Southclaws/storyden/internal/ent/asset"
	"github.com/Southclaws/storyden/internal/ent/collection"
	"github.com/Southclaws/storyden/internal/ent/link"
	"github.com/Southclaws/storyden/internal/ent/node"
	"github.com/Southclaws/storyden/internal/ent/predicate"
	"github.com/Southclaws/storyden/internal/ent/property"
	"github.com/Southclaws/storyden/internal/ent/propertyschema"
	"github.com/Southclaws/storyden/internal/ent/tag"
	"github.com/rs/xid"
)

// NodeUpdate is the builder for updating Node entities.
type NodeUpdate struct {
	config
	hooks     []Hook
	mutation  *NodeMutation
	modifiers []func(*sql.UpdateBuilder)
}

// Where appends a list predicates to the NodeUpdate builder.
func (nu *NodeUpdate) Where(ps ...predicate.Node) *NodeUpdate {
	nu.mutation.Where(ps...)
	return nu
}

// SetUpdatedAt sets the "updated_at" field.
func (nu *NodeUpdate) SetUpdatedAt(t time.Time) *NodeUpdate {
	nu.mutation.SetUpdatedAt(t)
	return nu
}

// SetDeletedAt sets the "deleted_at" field.
func (nu *NodeUpdate) SetDeletedAt(t time.Time) *NodeUpdate {
	nu.mutation.SetDeletedAt(t)
	return nu
}

// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableDeletedAt(t *time.Time) *NodeUpdate {
	if t != nil {
		nu.SetDeletedAt(*t)
	}
	return nu
}

// ClearDeletedAt clears the value of the "deleted_at" field.
func (nu *NodeUpdate) ClearDeletedAt() *NodeUpdate {
	nu.mutation.ClearDeletedAt()
	return nu
}

// SetIndexedAt sets the "indexed_at" field.
func (nu *NodeUpdate) SetIndexedAt(t time.Time) *NodeUpdate {
	nu.mutation.SetIndexedAt(t)
	return nu
}

// SetNillableIndexedAt sets the "indexed_at" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableIndexedAt(t *time.Time) *NodeUpdate {
	if t != nil {
		nu.SetIndexedAt(*t)
	}
	return nu
}

// ClearIndexedAt clears the value of the "indexed_at" field.
func (nu *NodeUpdate) ClearIndexedAt() *NodeUpdate {
	nu.mutation.ClearIndexedAt()
	return nu
}

// SetName sets the "name" field.
func (nu *NodeUpdate) SetName(s string) *NodeUpdate {
	nu.mutation.SetName(s)
	return nu
}

// SetNillableName sets the "name" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableName(s *string) *NodeUpdate {
	if s != nil {
		nu.SetName(*s)
	}
	return nu
}

// SetSlug sets the "slug" field.
func (nu *NodeUpdate) SetSlug(s string) *NodeUpdate {
	nu.mutation.SetSlug(s)
	return nu
}

// SetNillableSlug sets the "slug" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableSlug(s *string) *NodeUpdate {
	if s != nil {
		nu.SetSlug(*s)
	}
	return nu
}

// SetDescription sets the "description" field.
func (nu *NodeUpdate) SetDescription(s string) *NodeUpdate {
	nu.mutation.SetDescription(s)
	return nu
}

// SetNillableDescription sets the "description" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableDescription(s *string) *NodeUpdate {
	if s != nil {
		nu.SetDescription(*s)
	}
	return nu
}

// ClearDescription clears the value of the "description" field.
func (nu *NodeUpdate) ClearDescription() *NodeUpdate {
	nu.mutation.ClearDescription()
	return nu
}

// SetContent sets the "content" field.
func (nu *NodeUpdate) SetContent(s string) *NodeUpdate {
	nu.mutation.SetContent(s)
	return nu
}

// SetNillableContent sets the "content" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableContent(s *string) *NodeUpdate {
	if s != nil {
		nu.SetContent(*s)
	}
	return nu
}

// ClearContent clears the value of the "content" field.
func (nu *NodeUpdate) ClearContent() *NodeUpdate {
	nu.mutation.ClearContent()
	return nu
}

// SetParentNodeID sets the "parent_node_id" field.
func (nu *NodeUpdate) SetParentNodeID(x xid.ID) *NodeUpdate {
	nu.mutation.SetParentNodeID(x)
	return nu
}

// SetNillableParentNodeID sets the "parent_node_id" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableParentNodeID(x *xid.ID) *NodeUpdate {
	if x != nil {
		nu.SetParentNodeID(*x)
	}
	return nu
}

// ClearParentNodeID clears the value of the "parent_node_id" field.
func (nu *NodeUpdate) ClearParentNodeID() *NodeUpdate {
	nu.mutation.ClearParentNodeID()
	return nu
}

// SetHideChildTree sets the "hide_child_tree" field.
func (nu *NodeUpdate) SetHideChildTree(b bool) *NodeUpdate {
	nu.mutation.SetHideChildTree(b)
	return nu
}

// SetNillableHideChildTree sets the "hide_child_tree" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableHideChildTree(b *bool) *NodeUpdate {
	if b != nil {
		nu.SetHideChildTree(*b)
	}
	return nu
}

// SetAccountID sets the "account_id" field.
func (nu *NodeUpdate) SetAccountID(x xid.ID) *NodeUpdate {
	nu.mutation.SetAccountID(x)
	return nu
}

// SetNillableAccountID sets the "account_id" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableAccountID(x *xid.ID) *NodeUpdate {
	if x != nil {
		nu.SetAccountID(*x)
	}
	return nu
}

// SetPropertySchemaID sets the "property_schema_id" field.
func (nu *NodeUpdate) SetPropertySchemaID(x xid.ID) *NodeUpdate {
	nu.mutation.SetPropertySchemaID(x)
	return nu
}

// SetNillablePropertySchemaID sets the "property_schema_id" field if the given value is not nil.
func (nu *NodeUpdate) SetNillablePropertySchemaID(x *xid.ID) *NodeUpdate {
	if x != nil {
		nu.SetPropertySchemaID(*x)
	}
	return nu
}

// ClearPropertySchemaID clears the value of the "property_schema_id" field.
func (nu *NodeUpdate) ClearPropertySchemaID() *NodeUpdate {
	nu.mutation.ClearPropertySchemaID()
	return nu
}

// SetPrimaryAssetID sets the "primary_asset_id" field.
func (nu *NodeUpdate) SetPrimaryAssetID(x xid.ID) *NodeUpdate {
	nu.mutation.SetPrimaryAssetID(x)
	return nu
}

// SetNillablePrimaryAssetID sets the "primary_asset_id" field if the given value is not nil.
func (nu *NodeUpdate) SetNillablePrimaryAssetID(x *xid.ID) *NodeUpdate {
	if x != nil {
		nu.SetPrimaryAssetID(*x)
	}
	return nu
}

// ClearPrimaryAssetID clears the value of the "primary_asset_id" field.
func (nu *NodeUpdate) ClearPrimaryAssetID() *NodeUpdate {
	nu.mutation.ClearPrimaryAssetID()
	return nu
}

// SetLinkID sets the "link_id" field.
func (nu *NodeUpdate) SetLinkID(x xid.ID) *NodeUpdate {
	nu.mutation.SetLinkID(x)
	return nu
}

// SetNillableLinkID sets the "link_id" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableLinkID(x *xid.ID) *NodeUpdate {
	if x != nil {
		nu.SetLinkID(*x)
	}
	return nu
}

// ClearLinkID clears the value of the "link_id" field.
func (nu *NodeUpdate) ClearLinkID() *NodeUpdate {
	nu.mutation.ClearLinkID()
	return nu
}

// SetVisibility sets the "visibility" field.
func (nu *NodeUpdate) SetVisibility(n node.Visibility) *NodeUpdate {
	nu.mutation.SetVisibility(n)
	return nu
}

// SetNillableVisibility sets the "visibility" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableVisibility(n *node.Visibility) *NodeUpdate {
	if n != nil {
		nu.SetVisibility(*n)
	}
	return nu
}

// SetSort sets the "sort" field.
func (nu *NodeUpdate) SetSort(l lexorank.Key) *NodeUpdate {
	nu.mutation.SetSort(l)
	return nu
}

// SetNillableSort sets the "sort" field if the given value is not nil.
func (nu *NodeUpdate) SetNillableSort(l *lexorank.Key) *NodeUpdate {
	if l != nil {
		nu.SetSort(*l)
	}
	return nu
}

// SetMetadata sets the "metadata" field.
func (nu *NodeUpdate) SetMetadata(m map[string]interface{}) *NodeUpdate {
	nu.mutation.SetMetadata(m)
	return nu
}

// ClearMetadata clears the value of the "metadata" field.
func (nu *NodeUpdate) ClearMetadata() *NodeUpdate {
	nu.mutation.ClearMetadata()
	return nu
}

// SetOwnerID sets the "owner" edge to the Account entity by ID.
func (nu *NodeUpdate) SetOwnerID(id xid.ID) *NodeUpdate {
	nu.mutation.SetOwnerID(id)
	return nu
}

// SetOwner sets the "owner" edge to the Account entity.
func (nu *NodeUpdate) SetOwner(a *Account) *NodeUpdate {
	return nu.SetOwnerID(a.ID)
}

// SetParentID sets the "parent" edge to the Node entity by ID.
func (nu *NodeUpdate) SetParentID(id xid.ID) *NodeUpdate {
	nu.mutation.SetParentID(id)
	return nu
}

// SetNillableParentID sets the "parent" edge to the Node entity by ID if the given value is not nil.
func (nu *NodeUpdate) SetNillableParentID(id *xid.ID) *NodeUpdate {
	if id != nil {
		nu = nu.SetParentID(*id)
	}
	return nu
}

// SetParent sets the "parent" edge to the Node entity.
func (nu *NodeUpdate) SetParent(n *Node) *NodeUpdate {
	return nu.SetParentID(n.ID)
}

// AddNodeIDs adds the "nodes" edge to the Node entity by IDs.
func (nu *NodeUpdate) AddNodeIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddNodeIDs(ids...)
	return nu
}

// AddNodes adds the "nodes" edges to the Node entity.
func (nu *NodeUpdate) AddNodes(n ...*Node) *NodeUpdate {
	ids := make([]xid.ID, len(n))
	for i := range n {
		ids[i] = n[i].ID
	}
	return nu.AddNodeIDs(ids...)
}

// SetPrimaryImageID sets the "primary_image" edge to the Asset entity by ID.
func (nu *NodeUpdate) SetPrimaryImageID(id xid.ID) *NodeUpdate {
	nu.mutation.SetPrimaryImageID(id)
	return nu
}

// SetNillablePrimaryImageID sets the "primary_image" edge to the Asset entity by ID if the given value is not nil.
func (nu *NodeUpdate) SetNillablePrimaryImageID(id *xid.ID) *NodeUpdate {
	if id != nil {
		nu = nu.SetPrimaryImageID(*id)
	}
	return nu
}

// SetPrimaryImage sets the "primary_image" edge to the Asset entity.
func (nu *NodeUpdate) SetPrimaryImage(a *Asset) *NodeUpdate {
	return nu.SetPrimaryImageID(a.ID)
}

// AddAssetIDs adds the "assets" edge to the Asset entity by IDs.
func (nu *NodeUpdate) AddAssetIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddAssetIDs(ids...)
	return nu
}

// AddAssets adds the "assets" edges to the Asset entity.
func (nu *NodeUpdate) AddAssets(a ...*Asset) *NodeUpdate {
	ids := make([]xid.ID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return nu.AddAssetIDs(ids...)
}

// AddTagIDs adds the "tags" edge to the Tag entity by IDs.
func (nu *NodeUpdate) AddTagIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddTagIDs(ids...)
	return nu
}

// AddTags adds the "tags" edges to the Tag entity.
func (nu *NodeUpdate) AddTags(t ...*Tag) *NodeUpdate {
	ids := make([]xid.ID, len(t))
	for i := range t {
		ids[i] = t[i].ID
	}
	return nu.AddTagIDs(ids...)
}

// AddPropertyIDs adds the "properties" edge to the Property entity by IDs.
func (nu *NodeUpdate) AddPropertyIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddPropertyIDs(ids...)
	return nu
}

// AddProperties adds the "properties" edges to the Property entity.
func (nu *NodeUpdate) AddProperties(p ...*Property) *NodeUpdate {
	ids := make([]xid.ID, len(p))
	for i := range p {
		ids[i] = p[i].ID
	}
	return nu.AddPropertyIDs(ids...)
}

// SetPropertySchema sets the "property_schema" edge to the PropertySchema entity.
func (nu *NodeUpdate) SetPropertySchema(p *PropertySchema) *NodeUpdate {
	return nu.SetPropertySchemaID(p.ID)
}

// SetLink sets the "link" edge to the Link entity.
func (nu *NodeUpdate) SetLink(l *Link) *NodeUpdate {
	return nu.SetLinkID(l.ID)
}

// AddContentLinkIDs adds the "content_links" edge to the Link entity by IDs.
func (nu *NodeUpdate) AddContentLinkIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddContentLinkIDs(ids...)
	return nu
}

// AddContentLinks adds the "content_links" edges to the Link entity.
func (nu *NodeUpdate) AddContentLinks(l ...*Link) *NodeUpdate {
	ids := make([]xid.ID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return nu.AddContentLinkIDs(ids...)
}

// AddCollectionIDs adds the "collections" edge to the Collection entity by IDs.
func (nu *NodeUpdate) AddCollectionIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.AddCollectionIDs(ids...)
	return nu
}

// AddCollections adds the "collections" edges to the Collection entity.
func (nu *NodeUpdate) AddCollections(c ...*Collection) *NodeUpdate {
	ids := make([]xid.ID, len(c))
	for i := range c {
		ids[i] = c[i].ID
	}
	return nu.AddCollectionIDs(ids...)
}

// Mutation returns the NodeMutation object of the builder.
func (nu *NodeUpdate) Mutation() *NodeMutation {
	return nu.mutation
}

// ClearOwner clears the "owner" edge to the Account entity.
func (nu *NodeUpdate) ClearOwner() *NodeUpdate {
	nu.mutation.ClearOwner()
	return nu
}

// ClearParent clears the "parent" edge to the Node entity.
func (nu *NodeUpdate) ClearParent() *NodeUpdate {
	nu.mutation.ClearParent()
	return nu
}

// ClearNodes clears all "nodes" edges to the Node entity.
func (nu *NodeUpdate) ClearNodes() *NodeUpdate {
	nu.mutation.ClearNodes()
	return nu
}

// RemoveNodeIDs removes the "nodes" edge to Node entities by IDs.
func (nu *NodeUpdate) RemoveNodeIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemoveNodeIDs(ids...)
	return nu
}

// RemoveNodes removes "nodes" edges to Node entities.
func (nu *NodeUpdate) RemoveNodes(n ...*Node) *NodeUpdate {
	ids := make([]xid.ID, len(n))
	for i := range n {
		ids[i] = n[i].ID
	}
	return nu.RemoveNodeIDs(ids...)
}

// ClearPrimaryImage clears the "primary_image" edge to the Asset entity.
func (nu *NodeUpdate) ClearPrimaryImage() *NodeUpdate {
	nu.mutation.ClearPrimaryImage()
	return nu
}

// ClearAssets clears all "assets" edges to the Asset entity.
func (nu *NodeUpdate) ClearAssets() *NodeUpdate {
	nu.mutation.ClearAssets()
	return nu
}

// RemoveAssetIDs removes the "assets" edge to Asset entities by IDs.
func (nu *NodeUpdate) RemoveAssetIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemoveAssetIDs(ids...)
	return nu
}

// RemoveAssets removes "assets" edges to Asset entities.
func (nu *NodeUpdate) RemoveAssets(a ...*Asset) *NodeUpdate {
	ids := make([]xid.ID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return nu.RemoveAssetIDs(ids...)
}

// ClearTags clears all "tags" edges to the Tag entity.
func (nu *NodeUpdate) ClearTags() *NodeUpdate {
	nu.mutation.ClearTags()
	return nu
}

// RemoveTagIDs removes the "tags" edge to Tag entities by IDs.
func (nu *NodeUpdate) RemoveTagIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemoveTagIDs(ids...)
	return nu
}

// RemoveTags removes "tags" edges to Tag entities.
func (nu *NodeUpdate) RemoveTags(t ...*Tag) *NodeUpdate {
	ids := make([]xid.ID, len(t))
	for i := range t {
		ids[i] = t[i].ID
	}
	return nu.RemoveTagIDs(ids...)
}

// ClearProperties clears all "properties" edges to the Property entity.
func (nu *NodeUpdate) ClearProperties() *NodeUpdate {
	nu.mutation.ClearProperties()
	return nu
}

// RemovePropertyIDs removes the "properties" edge to Property entities by IDs.
func (nu *NodeUpdate) RemovePropertyIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemovePropertyIDs(ids...)
	return nu
}

// RemoveProperties removes "properties" edges to Property entities.
func (nu *NodeUpdate) RemoveProperties(p ...*Property) *NodeUpdate {
	ids := make([]xid.ID, len(p))
	for i := range p {
		ids[i] = p[i].ID
	}
	return nu.RemovePropertyIDs(ids...)
}

// ClearPropertySchema clears the "property_schema" edge to the PropertySchema entity.
func (nu *NodeUpdate) ClearPropertySchema() *NodeUpdate {
	nu.mutation.ClearPropertySchema()
	return nu
}

// ClearLink clears the "link" edge to the Link entity.
func (nu *NodeUpdate) ClearLink() *NodeUpdate {
	nu.mutation.ClearLink()
	return nu
}

// ClearContentLinks clears all "content_links" edges to the Link entity.
func (nu *NodeUpdate) ClearContentLinks() *NodeUpdate {
	nu.mutation.ClearContentLinks()
	return nu
}

// RemoveContentLinkIDs removes the "content_links" edge to Link entities by IDs.
func (nu *NodeUpdate) RemoveContentLinkIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemoveContentLinkIDs(ids...)
	return nu
}

// RemoveContentLinks removes "content_links" edges to Link entities.
func (nu *NodeUpdate) RemoveContentLinks(l ...*Link) *NodeUpdate {
	ids := make([]xid.ID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return nu.RemoveContentLinkIDs(ids...)
}

// ClearCollections clears all "collections" edges to the Collection entity.
func (nu *NodeUpdate) ClearCollections() *NodeUpdate {
	nu.mutation.ClearCollections()
	return nu
}

// RemoveCollectionIDs removes the "collections" edge to Collection entities by IDs.
func (nu *NodeUpdate) RemoveCollectionIDs(ids ...xid.ID) *NodeUpdate {
	nu.mutation.RemoveCollectionIDs(ids...)
	return nu
}

// RemoveCollections removes "collections" edges to Collection entities.
func (nu *NodeUpdate) RemoveCollections(c ...*Collection) *NodeUpdate {
	ids := make([]xid.ID, len(c))
	for i := range c {
		ids[i] = c[i].ID
	}
	return nu.RemoveCollectionIDs(ids...)
}

// Save executes the query and returns the number of nodes affected by the update operation.
func (nu *NodeUpdate) Save(ctx context.Context) (int, error) {
	nu.defaults()
	return withHooks(ctx, nu.sqlSave, nu.mutation, nu.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (nu *NodeUpdate) SaveX(ctx context.Context) int {
	affected, err := nu.Save(ctx)
	if err != nil {
		panic(err)
	}
	return affected
}

// Exec executes the query.
func (nu *NodeUpdate) Exec(ctx context.Context) error {
	_, err := nu.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (nu *NodeUpdate) ExecX(ctx context.Context) {
	if err := nu.Exec(ctx); err != nil {
		panic(err)
	}
}

// defaults sets the default values of the builder before save.
func (nu *NodeUpdate) defaults() {
	if _, ok := nu.mutation.UpdatedAt(); !ok {
		v := node.UpdateDefaultUpdatedAt()
		nu.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (nu *NodeUpdate) check() error {
	if v, ok := nu.mutation.Visibility(); ok {
		if err := node.VisibilityValidator(v); err != nil {
			return &ValidationError{Name: "visibility", err: fmt.Errorf(`ent: validator failed for field "Node.visibility": %w`, err)}
		}
	}
	if nu.mutation.OwnerCleared() && len(nu.mutation.OwnerIDs()) > 0 {
		return errors.New(`ent: clearing a required unique edge "Node.owner"`)
	}
	return nil
}

// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
func (nu *NodeUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *NodeUpdate {
	nu.modifiers = append(nu.modifiers, modifiers...)
	return nu
}

func (nu *NodeUpdate) sqlSave(ctx context.Context) (n int, err error) {
	if err := nu.check(); err != nil {
		return n, err
	}
	_spec := sqlgraph.NewUpdateSpec(node.Table, node.Columns, sqlgraph.NewFieldSpec(node.FieldID, field.TypeString))
	if ps := nu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := nu.mutation.UpdatedAt(); ok {
		_spec.SetField(node.FieldUpdatedAt, field.TypeTime, value)
	}
	if value, ok := nu.mutation.DeletedAt(); ok {
		_spec.SetField(node.FieldDeletedAt, field.TypeTime, value)
	}
	if nu.mutation.DeletedAtCleared() {
		_spec.ClearField(node.FieldDeletedAt, field.TypeTime)
	}
	if value, ok := nu.mutation.IndexedAt(); ok {
		_spec.SetField(node.FieldIndexedAt, field.TypeTime, value)
	}
	if nu.mutation.IndexedAtCleared() {
		_spec.ClearField(node.FieldIndexedAt, field.TypeTime)
	}
	if value, ok := nu.mutation.Name(); ok {
		_spec.SetField(node.FieldName, field.TypeString, value)
	}
	if value, ok := nu.mutation.Slug(); ok {
		_spec.SetField(node.FieldSlug, field.TypeString, value)
	}
	if value, ok := nu.mutation.Description(); ok {
		_spec.SetField(node.FieldDescription, field.TypeString, value)
	}
	if nu.mutation.DescriptionCleared() {
		_spec.ClearField(node.FieldDescription, field.TypeString)
	}
	if value, ok := nu.mutation.Content(); ok {
		_spec.SetField(node.FieldContent, field.TypeString, value)
	}
	if nu.mutation.ContentCleared() {
		_spec.ClearField(node.FieldContent, field.TypeString)
	}
	if value, ok := nu.mutation.HideChildTree(); ok {
		_spec.SetField(node.FieldHideChildTree, field.TypeBool, value)
	}
	if value, ok := nu.mutation.Visibility(); ok {
		_spec.SetField(node.FieldVisibility, field.TypeEnum, value)
	}
	if value, ok := nu.mutation.Sort(); ok {
		_spec.SetField(node.FieldSort, field.TypeString, value)
	}
	if value, ok := nu.mutation.Metadata(); ok {
		_spec.SetField(node.FieldMetadata, field.TypeJSON, value)
	}
	if nu.mutation.MetadataCleared() {
		_spec.ClearField(node.FieldMetadata, field.TypeJSON)
	}
	if nu.mutation.OwnerCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.OwnerTable,
			Columns: []string{node.OwnerColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.OwnerIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.OwnerTable,
			Columns: []string{node.OwnerColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.ParentCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.ParentTable,
			Columns: []string{node.ParentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.ParentIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.ParentTable,
			Columns: []string{node.ParentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.NodesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedNodesIDs(); len(nodes) > 0 && !nu.mutation.NodesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.NodesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.PrimaryImageCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   node.PrimaryImageTable,
			Columns: []string{node.PrimaryImageColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.PrimaryImageIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   node.PrimaryImageTable,
			Columns: []string{node.PrimaryImageColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.AssetsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedAssetsIDs(); len(nodes) > 0 && !nu.mutation.AssetsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.AssetsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.TagsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedTagsIDs(); len(nodes) > 0 && !nu.mutation.TagsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.TagsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.PropertiesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedPropertiesIDs(); len(nodes) > 0 && !nu.mutation.PropertiesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.PropertiesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.PropertySchemaCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.PropertySchemaTable,
			Columns: []string{node.PropertySchemaColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(propertyschema.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.PropertySchemaIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.PropertySchemaTable,
			Columns: []string{node.PropertySchemaColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(propertyschema.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.LinkCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.LinkTable,
			Columns: []string{node.LinkColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.LinkIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.LinkTable,
			Columns: []string{node.LinkColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.ContentLinksCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedContentLinksIDs(); len(nodes) > 0 && !nu.mutation.ContentLinksCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.ContentLinksIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nu.mutation.CollectionsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		createE := &CollectionNodeCreate{config: nu.config, mutation: newCollectionNodeMutation(nu.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.RemovedCollectionsIDs(); len(nodes) > 0 && !nu.mutation.CollectionsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		createE := &CollectionNodeCreate{config: nu.config, mutation: newCollectionNodeMutation(nu.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nu.mutation.CollectionsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		createE := &CollectionNodeCreate{config: nu.config, mutation: newCollectionNodeMutation(nu.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	_spec.AddModifiers(nu.modifiers...)
	if n, err = sqlgraph.UpdateNodes(ctx, nu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{node.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return 0, err
	}
	nu.mutation.done = true
	return n, nil
}

// NodeUpdateOne is the builder for updating a single Node entity.
type NodeUpdateOne struct {
	config
	fields    []string
	hooks     []Hook
	mutation  *NodeMutation
	modifiers []func(*sql.UpdateBuilder)
}

// SetUpdatedAt sets the "updated_at" field.
func (nuo *NodeUpdateOne) SetUpdatedAt(t time.Time) *NodeUpdateOne {
	nuo.mutation.SetUpdatedAt(t)
	return nuo
}

// SetDeletedAt sets the "deleted_at" field.
func (nuo *NodeUpdateOne) SetDeletedAt(t time.Time) *NodeUpdateOne {
	nuo.mutation.SetDeletedAt(t)
	return nuo
}

// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableDeletedAt(t *time.Time) *NodeUpdateOne {
	if t != nil {
		nuo.SetDeletedAt(*t)
	}
	return nuo
}

// ClearDeletedAt clears the value of the "deleted_at" field.
func (nuo *NodeUpdateOne) ClearDeletedAt() *NodeUpdateOne {
	nuo.mutation.ClearDeletedAt()
	return nuo
}

// SetIndexedAt sets the "indexed_at" field.
func (nuo *NodeUpdateOne) SetIndexedAt(t time.Time) *NodeUpdateOne {
	nuo.mutation.SetIndexedAt(t)
	return nuo
}

// SetNillableIndexedAt sets the "indexed_at" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableIndexedAt(t *time.Time) *NodeUpdateOne {
	if t != nil {
		nuo.SetIndexedAt(*t)
	}
	return nuo
}

// ClearIndexedAt clears the value of the "indexed_at" field.
func (nuo *NodeUpdateOne) ClearIndexedAt() *NodeUpdateOne {
	nuo.mutation.ClearIndexedAt()
	return nuo
}

// SetName sets the "name" field.
func (nuo *NodeUpdateOne) SetName(s string) *NodeUpdateOne {
	nuo.mutation.SetName(s)
	return nuo
}

// SetNillableName sets the "name" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableName(s *string) *NodeUpdateOne {
	if s != nil {
		nuo.SetName(*s)
	}
	return nuo
}

// SetSlug sets the "slug" field.
func (nuo *NodeUpdateOne) SetSlug(s string) *NodeUpdateOne {
	nuo.mutation.SetSlug(s)
	return nuo
}

// SetNillableSlug sets the "slug" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableSlug(s *string) *NodeUpdateOne {
	if s != nil {
		nuo.SetSlug(*s)
	}
	return nuo
}

// SetDescription sets the "description" field.
func (nuo *NodeUpdateOne) SetDescription(s string) *NodeUpdateOne {
	nuo.mutation.SetDescription(s)
	return nuo
}

// SetNillableDescription sets the "description" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableDescription(s *string) *NodeUpdateOne {
	if s != nil {
		nuo.SetDescription(*s)
	}
	return nuo
}

// ClearDescription clears the value of the "description" field.
func (nuo *NodeUpdateOne) ClearDescription() *NodeUpdateOne {
	nuo.mutation.ClearDescription()
	return nuo
}

// SetContent sets the "content" field.
func (nuo *NodeUpdateOne) SetContent(s string) *NodeUpdateOne {
	nuo.mutation.SetContent(s)
	return nuo
}

// SetNillableContent sets the "content" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableContent(s *string) *NodeUpdateOne {
	if s != nil {
		nuo.SetContent(*s)
	}
	return nuo
}

// ClearContent clears the value of the "content" field.
func (nuo *NodeUpdateOne) ClearContent() *NodeUpdateOne {
	nuo.mutation.ClearContent()
	return nuo
}

// SetParentNodeID sets the "parent_node_id" field.
func (nuo *NodeUpdateOne) SetParentNodeID(x xid.ID) *NodeUpdateOne {
	nuo.mutation.SetParentNodeID(x)
	return nuo
}

// SetNillableParentNodeID sets the "parent_node_id" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableParentNodeID(x *xid.ID) *NodeUpdateOne {
	if x != nil {
		nuo.SetParentNodeID(*x)
	}
	return nuo
}

// ClearParentNodeID clears the value of the "parent_node_id" field.
func (nuo *NodeUpdateOne) ClearParentNodeID() *NodeUpdateOne {
	nuo.mutation.ClearParentNodeID()
	return nuo
}

// SetHideChildTree sets the "hide_child_tree" field.
func (nuo *NodeUpdateOne) SetHideChildTree(b bool) *NodeUpdateOne {
	nuo.mutation.SetHideChildTree(b)
	return nuo
}

// SetNillableHideChildTree sets the "hide_child_tree" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableHideChildTree(b *bool) *NodeUpdateOne {
	if b != nil {
		nuo.SetHideChildTree(*b)
	}
	return nuo
}

// SetAccountID sets the "account_id" field.
func (nuo *NodeUpdateOne) SetAccountID(x xid.ID) *NodeUpdateOne {
	nuo.mutation.SetAccountID(x)
	return nuo
}

// SetNillableAccountID sets the "account_id" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableAccountID(x *xid.ID) *NodeUpdateOne {
	if x != nil {
		nuo.SetAccountID(*x)
	}
	return nuo
}

// SetPropertySchemaID sets the "property_schema_id" field.
func (nuo *NodeUpdateOne) SetPropertySchemaID(x xid.ID) *NodeUpdateOne {
	nuo.mutation.SetPropertySchemaID(x)
	return nuo
}

// SetNillablePropertySchemaID sets the "property_schema_id" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillablePropertySchemaID(x *xid.ID) *NodeUpdateOne {
	if x != nil {
		nuo.SetPropertySchemaID(*x)
	}
	return nuo
}

// ClearPropertySchemaID clears the value of the "property_schema_id" field.
func (nuo *NodeUpdateOne) ClearPropertySchemaID() *NodeUpdateOne {
	nuo.mutation.ClearPropertySchemaID()
	return nuo
}

// SetPrimaryAssetID sets the "primary_asset_id" field.
func (nuo *NodeUpdateOne) SetPrimaryAssetID(x xid.ID) *NodeUpdateOne {
	nuo.mutation.SetPrimaryAssetID(x)
	return nuo
}

// SetNillablePrimaryAssetID sets the "primary_asset_id" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillablePrimaryAssetID(x *xid.ID) *NodeUpdateOne {
	if x != nil {
		nuo.SetPrimaryAssetID(*x)
	}
	return nuo
}

// ClearPrimaryAssetID clears the value of the "primary_asset_id" field.
func (nuo *NodeUpdateOne) ClearPrimaryAssetID() *NodeUpdateOne {
	nuo.mutation.ClearPrimaryAssetID()
	return nuo
}

// SetLinkID sets the "link_id" field.
func (nuo *NodeUpdateOne) SetLinkID(x xid.ID) *NodeUpdateOne {
	nuo.mutation.SetLinkID(x)
	return nuo
}

// SetNillableLinkID sets the "link_id" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableLinkID(x *xid.ID) *NodeUpdateOne {
	if x != nil {
		nuo.SetLinkID(*x)
	}
	return nuo
}

// ClearLinkID clears the value of the "link_id" field.
func (nuo *NodeUpdateOne) ClearLinkID() *NodeUpdateOne {
	nuo.mutation.ClearLinkID()
	return nuo
}

// SetVisibility sets the "visibility" field.
func (nuo *NodeUpdateOne) SetVisibility(n node.Visibility) *NodeUpdateOne {
	nuo.mutation.SetVisibility(n)
	return nuo
}

// SetNillableVisibility sets the "visibility" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableVisibility(n *node.Visibility) *NodeUpdateOne {
	if n != nil {
		nuo.SetVisibility(*n)
	}
	return nuo
}

// SetSort sets the "sort" field.
func (nuo *NodeUpdateOne) SetSort(l lexorank.Key) *NodeUpdateOne {
	nuo.mutation.SetSort(l)
	return nuo
}

// SetNillableSort sets the "sort" field if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableSort(l *lexorank.Key) *NodeUpdateOne {
	if l != nil {
		nuo.SetSort(*l)
	}
	return nuo
}

// SetMetadata sets the "metadata" field.
func (nuo *NodeUpdateOne) SetMetadata(m map[string]interface{}) *NodeUpdateOne {
	nuo.mutation.SetMetadata(m)
	return nuo
}

// ClearMetadata clears the value of the "metadata" field.
func (nuo *NodeUpdateOne) ClearMetadata() *NodeUpdateOne {
	nuo.mutation.ClearMetadata()
	return nuo
}

// SetOwnerID sets the "owner" edge to the Account entity by ID.
func (nuo *NodeUpdateOne) SetOwnerID(id xid.ID) *NodeUpdateOne {
	nuo.mutation.SetOwnerID(id)
	return nuo
}

// SetOwner sets the "owner" edge to the Account entity.
func (nuo *NodeUpdateOne) SetOwner(a *Account) *NodeUpdateOne {
	return nuo.SetOwnerID(a.ID)
}

// SetParentID sets the "parent" edge to the Node entity by ID.
func (nuo *NodeUpdateOne) SetParentID(id xid.ID) *NodeUpdateOne {
	nuo.mutation.SetParentID(id)
	return nuo
}

// SetNillableParentID sets the "parent" edge to the Node entity by ID if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillableParentID(id *xid.ID) *NodeUpdateOne {
	if id != nil {
		nuo = nuo.SetParentID(*id)
	}
	return nuo
}

// SetParent sets the "parent" edge to the Node entity.
func (nuo *NodeUpdateOne) SetParent(n *Node) *NodeUpdateOne {
	return nuo.SetParentID(n.ID)
}

// AddNodeIDs adds the "nodes" edge to the Node entity by IDs.
func (nuo *NodeUpdateOne) AddNodeIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddNodeIDs(ids...)
	return nuo
}

// AddNodes adds the "nodes" edges to the Node entity.
func (nuo *NodeUpdateOne) AddNodes(n ...*Node) *NodeUpdateOne {
	ids := make([]xid.ID, len(n))
	for i := range n {
		ids[i] = n[i].ID
	}
	return nuo.AddNodeIDs(ids...)
}

// SetPrimaryImageID sets the "primary_image" edge to the Asset entity by ID.
func (nuo *NodeUpdateOne) SetPrimaryImageID(id xid.ID) *NodeUpdateOne {
	nuo.mutation.SetPrimaryImageID(id)
	return nuo
}

// SetNillablePrimaryImageID sets the "primary_image" edge to the Asset entity by ID if the given value is not nil.
func (nuo *NodeUpdateOne) SetNillablePrimaryImageID(id *xid.ID) *NodeUpdateOne {
	if id != nil {
		nuo = nuo.SetPrimaryImageID(*id)
	}
	return nuo
}

// SetPrimaryImage sets the "primary_image" edge to the Asset entity.
func (nuo *NodeUpdateOne) SetPrimaryImage(a *Asset) *NodeUpdateOne {
	return nuo.SetPrimaryImageID(a.ID)
}

// AddAssetIDs adds the "assets" edge to the Asset entity by IDs.
func (nuo *NodeUpdateOne) AddAssetIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddAssetIDs(ids...)
	return nuo
}

// AddAssets adds the "assets" edges to the Asset entity.
func (nuo *NodeUpdateOne) AddAssets(a ...*Asset) *NodeUpdateOne {
	ids := make([]xid.ID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return nuo.AddAssetIDs(ids...)
}

// AddTagIDs adds the "tags" edge to the Tag entity by IDs.
func (nuo *NodeUpdateOne) AddTagIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddTagIDs(ids...)
	return nuo
}

// AddTags adds the "tags" edges to the Tag entity.
func (nuo *NodeUpdateOne) AddTags(t ...*Tag) *NodeUpdateOne {
	ids := make([]xid.ID, len(t))
	for i := range t {
		ids[i] = t[i].ID
	}
	return nuo.AddTagIDs(ids...)
}

// AddPropertyIDs adds the "properties" edge to the Property entity by IDs.
func (nuo *NodeUpdateOne) AddPropertyIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddPropertyIDs(ids...)
	return nuo
}

// AddProperties adds the "properties" edges to the Property entity.
func (nuo *NodeUpdateOne) AddProperties(p ...*Property) *NodeUpdateOne {
	ids := make([]xid.ID, len(p))
	for i := range p {
		ids[i] = p[i].ID
	}
	return nuo.AddPropertyIDs(ids...)
}

// SetPropertySchema sets the "property_schema" edge to the PropertySchema entity.
func (nuo *NodeUpdateOne) SetPropertySchema(p *PropertySchema) *NodeUpdateOne {
	return nuo.SetPropertySchemaID(p.ID)
}

// SetLink sets the "link" edge to the Link entity.
func (nuo *NodeUpdateOne) SetLink(l *Link) *NodeUpdateOne {
	return nuo.SetLinkID(l.ID)
}

// AddContentLinkIDs adds the "content_links" edge to the Link entity by IDs.
func (nuo *NodeUpdateOne) AddContentLinkIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddContentLinkIDs(ids...)
	return nuo
}

// AddContentLinks adds the "content_links" edges to the Link entity.
func (nuo *NodeUpdateOne) AddContentLinks(l ...*Link) *NodeUpdateOne {
	ids := make([]xid.ID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return nuo.AddContentLinkIDs(ids...)
}

// AddCollectionIDs adds the "collections" edge to the Collection entity by IDs.
func (nuo *NodeUpdateOne) AddCollectionIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.AddCollectionIDs(ids...)
	return nuo
}

// AddCollections adds the "collections" edges to the Collection entity.
func (nuo *NodeUpdateOne) AddCollections(c ...*Collection) *NodeUpdateOne {
	ids := make([]xid.ID, len(c))
	for i := range c {
		ids[i] = c[i].ID
	}
	return nuo.AddCollectionIDs(ids...)
}

// Mutation returns the NodeMutation object of the builder.
func (nuo *NodeUpdateOne) Mutation() *NodeMutation {
	return nuo.mutation
}

// ClearOwner clears the "owner" edge to the Account entity.
func (nuo *NodeUpdateOne) ClearOwner() *NodeUpdateOne {
	nuo.mutation.ClearOwner()
	return nuo
}

// ClearParent clears the "parent" edge to the Node entity.
func (nuo *NodeUpdateOne) ClearParent() *NodeUpdateOne {
	nuo.mutation.ClearParent()
	return nuo
}

// ClearNodes clears all "nodes" edges to the Node entity.
func (nuo *NodeUpdateOne) ClearNodes() *NodeUpdateOne {
	nuo.mutation.ClearNodes()
	return nuo
}

// RemoveNodeIDs removes the "nodes" edge to Node entities by IDs.
func (nuo *NodeUpdateOne) RemoveNodeIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemoveNodeIDs(ids...)
	return nuo
}

// RemoveNodes removes "nodes" edges to Node entities.
func (nuo *NodeUpdateOne) RemoveNodes(n ...*Node) *NodeUpdateOne {
	ids := make([]xid.ID, len(n))
	for i := range n {
		ids[i] = n[i].ID
	}
	return nuo.RemoveNodeIDs(ids...)
}

// ClearPrimaryImage clears the "primary_image" edge to the Asset entity.
func (nuo *NodeUpdateOne) ClearPrimaryImage() *NodeUpdateOne {
	nuo.mutation.ClearPrimaryImage()
	return nuo
}

// ClearAssets clears all "assets" edges to the Asset entity.
func (nuo *NodeUpdateOne) ClearAssets() *NodeUpdateOne {
	nuo.mutation.ClearAssets()
	return nuo
}

// RemoveAssetIDs removes the "assets" edge to Asset entities by IDs.
func (nuo *NodeUpdateOne) RemoveAssetIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemoveAssetIDs(ids...)
	return nuo
}

// RemoveAssets removes "assets" edges to Asset entities.
func (nuo *NodeUpdateOne) RemoveAssets(a ...*Asset) *NodeUpdateOne {
	ids := make([]xid.ID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return nuo.RemoveAssetIDs(ids...)
}

// ClearTags clears all "tags" edges to the Tag entity.
func (nuo *NodeUpdateOne) ClearTags() *NodeUpdateOne {
	nuo.mutation.ClearTags()
	return nuo
}

// RemoveTagIDs removes the "tags" edge to Tag entities by IDs.
func (nuo *NodeUpdateOne) RemoveTagIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemoveTagIDs(ids...)
	return nuo
}

// RemoveTags removes "tags" edges to Tag entities.
func (nuo *NodeUpdateOne) RemoveTags(t ...*Tag) *NodeUpdateOne {
	ids := make([]xid.ID, len(t))
	for i := range t {
		ids[i] = t[i].ID
	}
	return nuo.RemoveTagIDs(ids...)
}

// ClearProperties clears all "properties" edges to the Property entity.
func (nuo *NodeUpdateOne) ClearProperties() *NodeUpdateOne {
	nuo.mutation.ClearProperties()
	return nuo
}

// RemovePropertyIDs removes the "properties" edge to Property entities by IDs.
func (nuo *NodeUpdateOne) RemovePropertyIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemovePropertyIDs(ids...)
	return nuo
}

// RemoveProperties removes "properties" edges to Property entities.
func (nuo *NodeUpdateOne) RemoveProperties(p ...*Property) *NodeUpdateOne {
	ids := make([]xid.ID, len(p))
	for i := range p {
		ids[i] = p[i].ID
	}
	return nuo.RemovePropertyIDs(ids...)
}

// ClearPropertySchema clears the "property_schema" edge to the PropertySchema entity.
func (nuo *NodeUpdateOne) ClearPropertySchema() *NodeUpdateOne {
	nuo.mutation.ClearPropertySchema()
	return nuo
}

// ClearLink clears the "link" edge to the Link entity.
func (nuo *NodeUpdateOne) ClearLink() *NodeUpdateOne {
	nuo.mutation.ClearLink()
	return nuo
}

// ClearContentLinks clears all "content_links" edges to the Link entity.
func (nuo *NodeUpdateOne) ClearContentLinks() *NodeUpdateOne {
	nuo.mutation.ClearContentLinks()
	return nuo
}

// RemoveContentLinkIDs removes the "content_links" edge to Link entities by IDs.
func (nuo *NodeUpdateOne) RemoveContentLinkIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemoveContentLinkIDs(ids...)
	return nuo
}

// RemoveContentLinks removes "content_links" edges to Link entities.
func (nuo *NodeUpdateOne) RemoveContentLinks(l ...*Link) *NodeUpdateOne {
	ids := make([]xid.ID, len(l))
	for i := range l {
		ids[i] = l[i].ID
	}
	return nuo.RemoveContentLinkIDs(ids...)
}

// ClearCollections clears all "collections" edges to the Collection entity.
func (nuo *NodeUpdateOne) ClearCollections() *NodeUpdateOne {
	nuo.mutation.ClearCollections()
	return nuo
}

// RemoveCollectionIDs removes the "collections" edge to Collection entities by IDs.
func (nuo *NodeUpdateOne) RemoveCollectionIDs(ids ...xid.ID) *NodeUpdateOne {
	nuo.mutation.RemoveCollectionIDs(ids...)
	return nuo
}

// RemoveCollections removes "collections" edges to Collection entities.
func (nuo *NodeUpdateOne) RemoveCollections(c ...*Collection) *NodeUpdateOne {
	ids := make([]xid.ID, len(c))
	for i := range c {
		ids[i] = c[i].ID
	}
	return nuo.RemoveCollectionIDs(ids...)
}

// Where appends a list predicates to the NodeUpdate builder.
func (nuo *NodeUpdateOne) Where(ps ...predicate.Node) *NodeUpdateOne {
	nuo.mutation.Where(ps...)
	return nuo
}

// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (nuo *NodeUpdateOne) Select(field string, fields ...string) *NodeUpdateOne {
	nuo.fields = append([]string{field}, fields...)
	return nuo
}

// Save executes the query and returns the updated Node entity.
func (nuo *NodeUpdateOne) Save(ctx context.Context) (*Node, error) {
	nuo.defaults()
	return withHooks(ctx, nuo.sqlSave, nuo.mutation, nuo.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (nuo *NodeUpdateOne) SaveX(ctx context.Context) *Node {
	node, err := nuo.Save(ctx)
	if err != nil {
		panic(err)
	}
	return node
}

// Exec executes the query on the entity.
func (nuo *NodeUpdateOne) Exec(ctx context.Context) error {
	_, err := nuo.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (nuo *NodeUpdateOne) ExecX(ctx context.Context) {
	if err := nuo.Exec(ctx); err != nil {
		panic(err)
	}
}

// defaults sets the default values of the builder before save.
func (nuo *NodeUpdateOne) defaults() {
	if _, ok := nuo.mutation.UpdatedAt(); !ok {
		v := node.UpdateDefaultUpdatedAt()
		nuo.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (nuo *NodeUpdateOne) check() error {
	if v, ok := nuo.mutation.Visibility(); ok {
		if err := node.VisibilityValidator(v); err != nil {
			return &ValidationError{Name: "visibility", err: fmt.Errorf(`ent: validator failed for field "Node.visibility": %w`, err)}
		}
	}
	if nuo.mutation.OwnerCleared() && len(nuo.mutation.OwnerIDs()) > 0 {
		return errors.New(`ent: clearing a required unique edge "Node.owner"`)
	}
	return nil
}

// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
func (nuo *NodeUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *NodeUpdateOne {
	nuo.modifiers = append(nuo.modifiers, modifiers...)
	return nuo
}

func (nuo *NodeUpdateOne) sqlSave(ctx context.Context) (_node *Node, err error) {
	if err := nuo.check(); err != nil {
		return _node, err
	}
	_spec := sqlgraph.NewUpdateSpec(node.Table, node.Columns, sqlgraph.NewFieldSpec(node.FieldID, field.TypeString))
	id, ok := nuo.mutation.ID()
	if !ok {
		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Node.id" for update`)}
	}
	_spec.Node.ID.Value = id
	if fields := nuo.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, node.FieldID)
		for _, f := range fields {
			if !node.ValidColumn(f) {
				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
			}
			if f != node.FieldID {
				_spec.Node.Columns = append(_spec.Node.Columns, f)
			}
		}
	}
	if ps := nuo.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := nuo.mutation.UpdatedAt(); ok {
		_spec.SetField(node.FieldUpdatedAt, field.TypeTime, value)
	}
	if value, ok := nuo.mutation.DeletedAt(); ok {
		_spec.SetField(node.FieldDeletedAt, field.TypeTime, value)
	}
	if nuo.mutation.DeletedAtCleared() {
		_spec.ClearField(node.FieldDeletedAt, field.TypeTime)
	}
	if value, ok := nuo.mutation.IndexedAt(); ok {
		_spec.SetField(node.FieldIndexedAt, field.TypeTime, value)
	}
	if nuo.mutation.IndexedAtCleared() {
		_spec.ClearField(node.FieldIndexedAt, field.TypeTime)
	}
	if value, ok := nuo.mutation.Name(); ok {
		_spec.SetField(node.FieldName, field.TypeString, value)
	}
	if value, ok := nuo.mutation.Slug(); ok {
		_spec.SetField(node.FieldSlug, field.TypeString, value)
	}
	if value, ok := nuo.mutation.Description(); ok {
		_spec.SetField(node.FieldDescription, field.TypeString, value)
	}
	if nuo.mutation.DescriptionCleared() {
		_spec.ClearField(node.FieldDescription, field.TypeString)
	}
	if value, ok := nuo.mutation.Content(); ok {
		_spec.SetField(node.FieldContent, field.TypeString, value)
	}
	if nuo.mutation.ContentCleared() {
		_spec.ClearField(node.FieldContent, field.TypeString)
	}
	if value, ok := nuo.mutation.HideChildTree(); ok {
		_spec.SetField(node.FieldHideChildTree, field.TypeBool, value)
	}
	if value, ok := nuo.mutation.Visibility(); ok {
		_spec.SetField(node.FieldVisibility, field.TypeEnum, value)
	}
	if value, ok := nuo.mutation.Sort(); ok {
		_spec.SetField(node.FieldSort, field.TypeString, value)
	}
	if value, ok := nuo.mutation.Metadata(); ok {
		_spec.SetField(node.FieldMetadata, field.TypeJSON, value)
	}
	if nuo.mutation.MetadataCleared() {
		_spec.ClearField(node.FieldMetadata, field.TypeJSON)
	}
	if nuo.mutation.OwnerCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.OwnerTable,
			Columns: []string{node.OwnerColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.OwnerIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.OwnerTable,
			Columns: []string{node.OwnerColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(account.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.ParentCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.ParentTable,
			Columns: []string{node.ParentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.ParentIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.ParentTable,
			Columns: []string{node.ParentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.NodesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedNodesIDs(); len(nodes) > 0 && !nuo.mutation.NodesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.NodesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.NodesTable,
			Columns: []string{node.NodesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(node.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.PrimaryImageCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   node.PrimaryImageTable,
			Columns: []string{node.PrimaryImageColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.PrimaryImageIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   node.PrimaryImageTable,
			Columns: []string{node.PrimaryImageColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.AssetsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedAssetsIDs(); len(nodes) > 0 && !nuo.mutation.AssetsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.AssetsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   node.AssetsTable,
			Columns: node.AssetsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(asset.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.TagsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedTagsIDs(); len(nodes) > 0 && !nuo.mutation.TagsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.TagsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.TagsTable,
			Columns: node.TagsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(tag.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.PropertiesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedPropertiesIDs(); len(nodes) > 0 && !nuo.mutation.PropertiesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.PropertiesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   node.PropertiesTable,
			Columns: []string{node.PropertiesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(property.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.PropertySchemaCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.PropertySchemaTable,
			Columns: []string{node.PropertySchemaColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(propertyschema.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.PropertySchemaIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.PropertySchemaTable,
			Columns: []string{node.PropertySchemaColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(propertyschema.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.LinkCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.LinkTable,
			Columns: []string{node.LinkColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.LinkIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   node.LinkTable,
			Columns: []string{node.LinkColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.ContentLinksCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedContentLinksIDs(); len(nodes) > 0 && !nuo.mutation.ContentLinksCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.ContentLinksIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.ContentLinksTable,
			Columns: node.ContentLinksPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(link.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if nuo.mutation.CollectionsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		createE := &CollectionNodeCreate{config: nuo.config, mutation: newCollectionNodeMutation(nuo.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.RemovedCollectionsIDs(); len(nodes) > 0 && !nuo.mutation.CollectionsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		createE := &CollectionNodeCreate{config: nuo.config, mutation: newCollectionNodeMutation(nuo.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := nuo.mutation.CollectionsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   node.CollectionsTable,
			Columns: node.CollectionsPrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(collection.FieldID, field.TypeString),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		createE := &CollectionNodeCreate{config: nuo.config, mutation: newCollectionNodeMutation(nuo.config, OpCreate)}
		createE.defaults()
		_, specE := createE.createSpec()
		edge.Target.Fields = specE.Fields
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	_spec.AddModifiers(nuo.modifiers...)
	_node = &Node{config: nuo.config}
	_spec.Assign = _node.assignValues
	_spec.ScanValues = _node.scanValues
	if err = sqlgraph.UpdateNode(ctx, nuo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{node.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return nil, err
	}
	nuo.mutation.done = true
	return _node, nil
}