func (uuo *UserUpdateOne) SetBigInt(si schema.BigInt) *UserUpdateOne {
	uuo.mutation.SetBigInt(si)
	return uuo
}
SetBigInt sets the "big_int" field.
package ent
import (
	"context"
	"fmt"
	"entgo.io/contrib/entproto/internal/todo/ent/attachment"
	"entgo.io/contrib/entproto/internal/todo/ent/group"
	"entgo.io/contrib/entproto/internal/todo/ent/predicate"
	"entgo.io/contrib/entproto/internal/todo/ent/schema"
	"entgo.io/contrib/entproto/internal/todo/ent/user"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/google/uuid"
)
type UserUpdate struct {
	config
	hooks    []Hook
	mutation *UserMutation
}
func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
	uu.mutation.Where(ps...)
	return uu
}
func (uu *UserUpdate) SetUserName(s string) *UserUpdate {
	uu.mutation.SetUserName(s)
	return uu
}
func (uu *UserUpdate) SetPoints(u uint) *UserUpdate {
	uu.mutation.ResetPoints()
	uu.mutation.SetPoints(u)
	return uu
}
func (uu *UserUpdate) AddPoints(u uint) *UserUpdate {
	uu.mutation.AddPoints(u)
	return uu
}
func (uu *UserUpdate) SetExp(u uint64) *UserUpdate {
	uu.mutation.ResetExp()
	uu.mutation.SetExp(u)
	return uu
}
func (uu *UserUpdate) AddExp(u uint64) *UserUpdate {
	uu.mutation.AddExp(u)
	return uu
}
func (uu *UserUpdate) SetStatus(u user.Status) *UserUpdate {
	uu.mutation.SetStatus(u)
	return uu
}
func (uu *UserUpdate) SetExternalID(i int) *UserUpdate {
	uu.mutation.ResetExternalID()
	uu.mutation.SetExternalID(i)
	return uu
}
func (uu *UserUpdate) AddExternalID(i int) *UserUpdate {
	uu.mutation.AddExternalID(i)
	return uu
}
func (uu *UserUpdate) SetCrmID(u uuid.UUID) *UserUpdate {
	uu.mutation.SetCrmID(u)
	return uu
}
func (uu *UserUpdate) SetBanned(b bool) *UserUpdate {
	uu.mutation.SetBanned(b)
	return uu
}
func (uu *UserUpdate) SetNillableBanned(b *bool) *UserUpdate {
	if b != nil {
		uu.SetBanned(*b)
	}
	return uu
}
func (uu *UserUpdate) SetCustomPb(u uint8) *UserUpdate {
	uu.mutation.ResetCustomPb()
	uu.mutation.SetCustomPb(u)
	return uu
}
func (uu *UserUpdate) AddCustomPb(u uint8) *UserUpdate {
	uu.mutation.AddCustomPb(u)
	return uu
}
func (uu *UserUpdate) SetOptNum(i int) *UserUpdate {
	uu.mutation.ResetOptNum()
	uu.mutation.SetOptNum(i)
	return uu
}
func (uu *UserUpdate) SetNillableOptNum(i *int) *UserUpdate {
	if i != nil {
		uu.SetOptNum(*i)
	}
	return uu
}
func (uu *UserUpdate) AddOptNum(i int) *UserUpdate {
	uu.mutation.AddOptNum(i)
	return uu
}
func (uu *UserUpdate) ClearOptNum() *UserUpdate {
	uu.mutation.ClearOptNum()
	return uu
}
func (uu *UserUpdate) SetOptStr(s string) *UserUpdate {
	uu.mutation.SetOptStr(s)
	return uu
}
func (uu *UserUpdate) SetNillableOptStr(s *string) *UserUpdate {
	if s != nil {
		uu.SetOptStr(*s)
	}
	return uu
}
func (uu *UserUpdate) ClearOptStr() *UserUpdate {
	uu.mutation.ClearOptStr()
	return uu
}
func (uu *UserUpdate) SetOptBool(b bool) *UserUpdate {
	uu.mutation.SetOptBool(b)
	return uu
}
func (uu *UserUpdate) SetNillableOptBool(b *bool) *UserUpdate {
	if b != nil {
		uu.SetOptBool(*b)
	}
	return uu
}
func (uu *UserUpdate) ClearOptBool() *UserUpdate {
	uu.mutation.ClearOptBool()
	return uu
}
func (uu *UserUpdate) SetBigInt(si schema.BigInt) *UserUpdate {
	uu.mutation.SetBigInt(si)
	return uu
}
func (uu *UserUpdate) SetNillableBigInt(si *schema.BigInt) *UserUpdate {
	if si != nil {
		uu.SetBigInt(*si)
	}
	return uu
}
func (uu *UserUpdate) ClearBigInt() *UserUpdate {
	uu.mutation.ClearBigInt()
	return uu
}
func (uu *UserUpdate) SetBUser1(i int) *UserUpdate {
	uu.mutation.ResetBUser1()
	uu.mutation.SetBUser1(i)
	return uu
}
func (uu *UserUpdate) SetNillableBUser1(i *int) *UserUpdate {
	if i != nil {
		uu.SetBUser1(*i)
	}
	return uu
}
func (uu *UserUpdate) AddBUser1(i int) *UserUpdate {
	uu.mutation.AddBUser1(i)
	return uu
}
func (uu *UserUpdate) ClearBUser1() *UserUpdate {
	uu.mutation.ClearBUser1()
	return uu
}
func (uu *UserUpdate) SetGroupID(id int) *UserUpdate {
	uu.mutation.SetGroupID(id)
	return uu
}
func (uu *UserUpdate) SetNillableGroupID(id *int) *UserUpdate {
	if id != nil {
		uu = uu.SetGroupID(*id)
	}
	return uu
}
func (uu *UserUpdate) SetGroup(g *Group) *UserUpdate {
	return uu.SetGroupID(g.ID)
}
func (uu *UserUpdate) SetAttachmentID(id uuid.UUID) *UserUpdate {
	uu.mutation.SetAttachmentID(id)
	return uu
}
func (uu *UserUpdate) SetNillableAttachmentID(id *uuid.UUID) *UserUpdate {
	if id != nil {
		uu = uu.SetAttachmentID(*id)
	}
	return uu
}
func (uu *UserUpdate) SetAttachment(a *Attachment) *UserUpdate {
	return uu.SetAttachmentID(a.ID)
}
func (uu *UserUpdate) AddReceived1IDs(ids ...uuid.UUID) *UserUpdate {
	uu.mutation.AddReceived1IDs(ids...)
	return uu
}
func (uu *UserUpdate) AddReceived1(a ...*Attachment) *UserUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return uu.AddReceived1IDs(ids...)
}
func (uu *UserUpdate) Mutation() *UserMutation {
	return uu.mutation
}
func (uu *UserUpdate) ClearGroup() *UserUpdate {
	uu.mutation.ClearGroup()
	return uu
}
func (uu *UserUpdate) ClearAttachment() *UserUpdate {
	uu.mutation.ClearAttachment()
	return uu
}
func (uu *UserUpdate) ClearReceived1() *UserUpdate {
	uu.mutation.ClearReceived1()
	return uu
}
func (uu *UserUpdate) RemoveReceived1IDs(ids ...uuid.UUID) *UserUpdate {
	uu.mutation.RemoveReceived1IDs(ids...)
	return uu
}
func (uu *UserUpdate) RemoveReceived1(a ...*Attachment) *UserUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return uu.RemoveReceived1IDs(ids...)
}
func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
	var (
		err      error
		affected int
	)
	if len(uu.hooks) == 0 {
		if err = uu.check(); err != nil {
			return 0, err
		}
		affected, err = uu.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*UserMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = uu.check(); err != nil {
				return 0, err
			}
			uu.mutation = mutation
			affected, err = uu.sqlSave(ctx)
			mutation.done = true
			return affected, err
		})
		for i := len(uu.hooks) - 1; i >= 0; i-- {
			if uu.hooks[i] == nil {
				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = uu.hooks[i](mut)
		}
		if _, err := mut.Mutate(ctx, uu.mutation); err != nil {
			return 0, err
		}
	}
	return affected, err
}
func (uu *UserUpdate) SaveX(ctx context.Context) int {
	affected, err := uu.Save(ctx)
	if err != nil {
		panic(err)
	}
	return affected
}
func (uu *UserUpdate) Exec(ctx context.Context) error {
	_, err := uu.Save(ctx)
	return err
}
func (uu *UserUpdate) ExecX(ctx context.Context) {
	if err := uu.Exec(ctx); err != nil {
		panic(err)
	}
}
func (uu *UserUpdate) check() error {
	if v, ok := uu.mutation.Status(); ok {
		if err := user.StatusValidator(v); err != nil {
			return &ValidationError{Name: "status", err: fmt.Errorf("ent: validator failed for field \"status\": %w", err)}
		}
	}
	return nil
}
func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   user.Table,
			Columns: user.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: user.FieldID,
			},
		},
	}
	if ps := uu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := uu.mutation.UserName(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: user.FieldUserName,
		})
	}
	if value, ok := uu.mutation.Points(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  value,
			Column: user.FieldPoints,
		})
	}
	if value, ok := uu.mutation.AddedPoints(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint,
			Value:  value,
			Column: user.FieldPoints,
		})
	}
	if value, ok := uu.mutation.Exp(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  value,
			Column: user.FieldExp,
		})
	}
	if value, ok := uu.mutation.AddedExp(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint64,
			Value:  value,
			Column: user.FieldExp,
		})
	}
	if value, ok := uu.mutation.Status(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeEnum,
			Value:  value,
			Column: user.FieldStatus,
		})
	}
	if value, ok := uu.mutation.ExternalID(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldExternalID,
		})
	}
	if value, ok := uu.mutation.AddedExternalID(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldExternalID,
		})
	}
	if value, ok := uu.mutation.CrmID(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUUID,
			Value:  value,
			Column: user.FieldCrmID,
		})
	}
	if value, ok := uu.mutation.Banned(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Value:  value,
			Column: user.FieldBanned,
		})
	}
	if value, ok := uu.mutation.CustomPb(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  value,
			Column: user.FieldCustomPb,
		})
	}
	if value, ok := uu.mutation.AddedCustomPb(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeUint8,
			Value:  value,
			Column: user.FieldCustomPb,
		})
	}
	if value, ok := uu.mutation.OptNum(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldOptNum,
		})
	}
	if value, ok := uu.mutation.AddedOptNum(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldOptNum,
		})
	}
	if uu.mutation.OptNumCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: user.FieldOptNum,
		})
	}
	if value, ok := uu.mutation.OptStr(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: user.FieldOptStr,
		})
	}
	if uu.mutation.OptStrCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: user.FieldOptStr,
		})
	}
	if value, ok := uu.mutation.OptBool(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Value:  value,
			Column: user.FieldOptBool,
		})
	}
	if uu.mutation.OptBoolCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Column: user.FieldOptBool,
		})
	}
	if value, ok := uu.mutation.BigInt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldBigInt,
		})
	}
	if uu.mutation.BigIntCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: user.FieldBigInt,
		})
	}
	if value, ok := uu.mutation.BUser1(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldBUser1,
		})
	}
	if value, ok := uu.mutation.AddedBUser1(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Value:  value,
			Column: user.FieldBUser1,
		})
	}
	if uu.mutation.BUser1Cleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt,
			Column: user.FieldBUser1,
		})
	}
	if uu.mutation.GroupCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   user.GroupTable,
			Columns: []string{user.GroupColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeInt,
					Column: group.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := uu.mutation.GroupIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   user.GroupTable,
			Columns: []string{user.GroupColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeInt,
					Column: group.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if uu.mutation.AttachmentCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   user.AttachmentTable,
			Columns: []string{user.AttachmentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: attachment.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := uu.mutation.AttachmentIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2O,
			Inverse: false,
			Table:   user.AttachmentTable,
			Columns: []string{user.AttachmentColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: attachment.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if uu.mutation.Received1Cleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   user.Received1Table,
			Columns: user.Received1PrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: attachment.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := uu.mutation.RemovedReceived1IDs(); len(nodes) > 0 && !uu.mutation.Received1Cleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   user.Received1Table,
			Columns: user.Received1PrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: attachment.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := uu.mutation.Received1IDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   user.Received1Table,
			Columns: user.Received1PrimaryKey,
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeUUID,
					Column: attachment.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{user.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{err.Error(), err}
		}
		return 0, err
	}
	return n, nil
}
type UserUpdateOne struct {
	config
	fields   []string
	hooks    []Hook
	mutation *UserMutation
}
func (uuo *UserUpdateOne) SetUserName(s string) *UserUpdateOne {
	uuo.mutation.SetUserName(s)
	return uuo
}
func (uuo *UserUpdateOne) SetPoints(u uint) *UserUpdateOne {
	uuo.mutation.ResetPoints()
	uuo.mutation.SetPoints(u)
	return uuo
}
func (uuo *UserUpdateOne) AddPoints(u uint) *UserUpdateOne {
	uuo.mutation.AddPoints(u)
	return uuo
}
func (uuo *UserUpdateOne) SetExp(u uint64) *UserUpdateOne {
	uuo.mutation.ResetExp()
	uuo.mutation.SetExp(u)
	return uuo
}
func (uuo *UserUpdateOne) AddExp(u uint64) *UserUpdateOne {
	uuo.mutation.AddExp(u)
	return uuo
}
func (uuo *UserUpdateOne) SetStatus(u user.Status) *UserUpdateOne {
	uuo.mutation.SetStatus(u)
	return uuo
}
func (uuo *UserUpdateOne) SetExternalID(i int) *UserUpdateOne {
	uuo.mutation.ResetExternalID()
	uuo.mutation.SetExternalID(i)
	return uuo
}
func (uuo *UserUpdateOne) AddExternalID(i int) *UserUpdateOne {
	uuo.mutation.AddExternalID(i)
	return uuo
}
func (uuo *UserUpdateOne) SetCrmID(u uuid.UUID) *UserUpdateOne {
	uuo.mutation.SetCrmID(u)
	return uuo
}
func (uuo *UserUpdateOne) SetBanned(b bool) *UserUpdateOne {
	uuo.mutation.SetBanned(b)
	return uuo
}
func (uuo *UserUpdateOne) SetNillableBanned(b *bool) *UserUpdateOne {
	if b != nil {
		uuo.SetBanned(*b)
	}
	return uuo
}
func (uuo *UserUpdateOne) SetCustomPb(u uint8) *UserUpdateOne {
	uuo.mutation.ResetCustomPb()
	uuo.mutation.SetCustomPb(u)
	return uuo
}
func (uuo *UserUpdateOne) AddCustomPb(u uint8) *UserUpdateOne {
	uuo.mutation.AddCustomPb(u)
	return uuo
}
func (uuo *UserUpdateOne) SetOptNum(i int) *UserUpdateOne {
	uuo.mutation.ResetOptNum()
	uuo.mutation.SetOptNum(i)
	return uuo
}
func (uuo *UserUpdateOne) SetNillableOptNum(i *int) *UserUpdateOne {
	if i != nil {
		uuo.SetOptNum(*i)
	}
	return uuo
}
func (uuo *UserUpdateOne) AddOptNum(i int) *UserUpdateOne {
	uuo.mutation.AddOptNum(i)
	return uuo
}
func (uuo *UserUpdateOne) ClearOptNum() *UserUpdateOne {
	uuo.mutation.ClearOptNum()
	return uuo
}
func (uuo *UserUpdateOne) SetOptStr(s string) *UserUpdateOne {
	uuo.mutation.SetOptStr(s)
	return uuo
}
func (uuo *UserUpdateOne) SetNillableOptStr(s *string) *UserUpdateOne {
	if s != nil {
		uuo.SetOptStr(*s)
	}
	return uuo
}
func (uuo *UserUpdateOne) ClearOptStr() *UserUpdateOne {
	uuo.mutation.ClearOptStr()
	return uuo
}
func (uuo *UserUpdateOne) SetOptBool(b bool) *UserUpdateOne {
	uuo.mutation.SetOptBool(b)
	return uuo
}
func (uuo *UserUpdateOne) SetNillableOptBool(b *bool) *UserUpdateOne {
	if b != nil {
		uuo.SetOptBool(*b)
	}
	return uuo
}
func (uuo *UserUpdateOne) ClearOptBool() *UserUpdateOne {
	uuo.mutation.ClearOptBool()
	return uuo
}