api/ent/mutation.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"t/ent/predicate"
	"t/ent/users"
	"time"

	"entgo.io/ent"
)

const (
	// Operation types.
	OpCreate    = ent.OpCreate
	OpDelete    = ent.OpDelete
	OpDeleteOne = ent.OpDeleteOne
	OpUpdate    = ent.OpUpdate
	OpUpdateOne = ent.OpUpdateOne

	// Node types.
	TypeUsers = "Users"
)

// UsersMutation represents an operation that mutates the Users nodes in the graph.
type UsersMutation struct {
	config
	op            Op
	typ           string
	id            *int
	user          *string
	chara         *string
	skill         *int
	addskill      *int
	hp            *int
	addhp         *int
	attack        *int
	addattack     *int
	defense       *int
	adddefense    *int
	critical      *int
	addcritical   *int
	battle        *int
	addbattle     *int
	win           *int
	addwin        *int
	day           *int
	addday        *int
	percentage    *float64
	addpercentage *float64
	_limit        *bool
	status        *string
	comment       *string
	created_at    *time.Time
	next          *string
	updated_at    *time.Time
	url           *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Users, error)
	predicates    []predicate.Users
}

var _ ent.Mutation = (*UsersMutation)(nil)

// usersOption allows management of the mutation configuration using functional options.
type usersOption func(*UsersMutation)

// newUsersMutation creates new mutation for the Users entity.
func newUsersMutation(c config, op Op, opts ...usersOption) *UsersMutation {
	m := &UsersMutation{
		config:        c,
		op:            op,
		typ:           TypeUsers,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withUsersID sets the ID field of the mutation.
func withUsersID(id int) usersOption {
	return func(m *UsersMutation) {
		var (
			err   error
			once  sync.Once
			value *Users
		)
		m.oldValue = func(ctx context.Context) (*Users, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Users.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withUsers sets the old Users of the mutation.
func withUsers(node *Users) usersOption {
	return func(m *UsersMutation) {
		m.oldValue = func(context.Context) (*Users, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m UsersMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m UsersMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *UsersMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *UsersMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Users.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetUser sets the "user" field.
func (m *UsersMutation) SetUser(s string) {
	m.user = &s
}

// User returns the value of the "user" field in the mutation.
func (m *UsersMutation) User() (r string, exists bool) {
	v := m.user
	if v == nil {
		return
	}
	return *v, true
}

// OldUser returns the old "user" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldUser(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUser: %w", err)
	}
	return oldValue.User, nil
}

// ResetUser resets all changes to the "user" field.
func (m *UsersMutation) ResetUser() {
	m.user = nil
}

// SetChara sets the "chara" field.
func (m *UsersMutation) SetChara(s string) {
	m.chara = &s
}

// Chara returns the value of the "chara" field in the mutation.
func (m *UsersMutation) Chara() (r string, exists bool) {
	v := m.chara
	if v == nil {
		return
	}
	return *v, true
}

// OldChara returns the old "chara" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldChara(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldChara is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldChara requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldChara: %w", err)
	}
	return oldValue.Chara, nil
}

// ClearChara clears the value of the "chara" field.
func (m *UsersMutation) ClearChara() {
	m.chara = nil
	m.clearedFields[users.FieldChara] = struct{}{}
}

// CharaCleared returns if the "chara" field was cleared in this mutation.
func (m *UsersMutation) CharaCleared() bool {
	_, ok := m.clearedFields[users.FieldChara]
	return ok
}

// ResetChara resets all changes to the "chara" field.
func (m *UsersMutation) ResetChara() {
	m.chara = nil
	delete(m.clearedFields, users.FieldChara)
}

// SetSkill sets the "skill" field.
func (m *UsersMutation) SetSkill(i int) {
	m.skill = &i
	m.addskill = nil
}

// Skill returns the value of the "skill" field in the mutation.
func (m *UsersMutation) Skill() (r int, exists bool) {
	v := m.skill
	if v == nil {
		return
	}
	return *v, true
}

// OldSkill returns the old "skill" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldSkill(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSkill is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSkill requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSkill: %w", err)
	}
	return oldValue.Skill, nil
}

// AddSkill adds i to the "skill" field.
func (m *UsersMutation) AddSkill(i int) {
	if m.addskill != nil {
		*m.addskill += i
	} else {
		m.addskill = &i
	}
}

// AddedSkill returns the value that was added to the "skill" field in this mutation.
func (m *UsersMutation) AddedSkill() (r int, exists bool) {
	v := m.addskill
	if v == nil {
		return
	}
	return *v, true
}

// ClearSkill clears the value of the "skill" field.
func (m *UsersMutation) ClearSkill() {
	m.skill = nil
	m.addskill = nil
	m.clearedFields[users.FieldSkill] = struct{}{}
}

// SkillCleared returns if the "skill" field was cleared in this mutation.
func (m *UsersMutation) SkillCleared() bool {
	_, ok := m.clearedFields[users.FieldSkill]
	return ok
}

// ResetSkill resets all changes to the "skill" field.
func (m *UsersMutation) ResetSkill() {
	m.skill = nil
	m.addskill = nil
	delete(m.clearedFields, users.FieldSkill)
}

// SetHp sets the "hp" field.
func (m *UsersMutation) SetHp(i int) {
	m.hp = &i
	m.addhp = nil
}

// Hp returns the value of the "hp" field in the mutation.
func (m *UsersMutation) Hp() (r int, exists bool) {
	v := m.hp
	if v == nil {
		return
	}
	return *v, true
}

// OldHp returns the old "hp" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldHp(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldHp is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldHp requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldHp: %w", err)
	}
	return oldValue.Hp, nil
}

// AddHp adds i to the "hp" field.
func (m *UsersMutation) AddHp(i int) {
	if m.addhp != nil {
		*m.addhp += i
	} else {
		m.addhp = &i
	}
}

// AddedHp returns the value that was added to the "hp" field in this mutation.
func (m *UsersMutation) AddedHp() (r int, exists bool) {
	v := m.addhp
	if v == nil {
		return
	}
	return *v, true
}

// ClearHp clears the value of the "hp" field.
func (m *UsersMutation) ClearHp() {
	m.hp = nil
	m.addhp = nil
	m.clearedFields[users.FieldHp] = struct{}{}
}

// HpCleared returns if the "hp" field was cleared in this mutation.
func (m *UsersMutation) HpCleared() bool {
	_, ok := m.clearedFields[users.FieldHp]
	return ok
}

// ResetHp resets all changes to the "hp" field.
func (m *UsersMutation) ResetHp() {
	m.hp = nil
	m.addhp = nil
	delete(m.clearedFields, users.FieldHp)
}

// SetAttack sets the "attack" field.
func (m *UsersMutation) SetAttack(i int) {
	m.attack = &i
	m.addattack = nil
}

// Attack returns the value of the "attack" field in the mutation.
func (m *UsersMutation) Attack() (r int, exists bool) {
	v := m.attack
	if v == nil {
		return
	}
	return *v, true
}

// OldAttack returns the old "attack" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldAttack(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAttack is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAttack requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAttack: %w", err)
	}
	return oldValue.Attack, nil
}

// AddAttack adds i to the "attack" field.
func (m *UsersMutation) AddAttack(i int) {
	if m.addattack != nil {
		*m.addattack += i
	} else {
		m.addattack = &i
	}
}

// AddedAttack returns the value that was added to the "attack" field in this mutation.
func (m *UsersMutation) AddedAttack() (r int, exists bool) {
	v := m.addattack
	if v == nil {
		return
	}
	return *v, true
}

// ClearAttack clears the value of the "attack" field.
func (m *UsersMutation) ClearAttack() {
	m.attack = nil
	m.addattack = nil
	m.clearedFields[users.FieldAttack] = struct{}{}
}

// AttackCleared returns if the "attack" field was cleared in this mutation.
func (m *UsersMutation) AttackCleared() bool {
	_, ok := m.clearedFields[users.FieldAttack]
	return ok
}

// ResetAttack resets all changes to the "attack" field.
func (m *UsersMutation) ResetAttack() {
	m.attack = nil
	m.addattack = nil
	delete(m.clearedFields, users.FieldAttack)
}

// SetDefense sets the "defense" field.
func (m *UsersMutation) SetDefense(i int) {
	m.defense = &i
	m.adddefense = nil
}

// Defense returns the value of the "defense" field in the mutation.
func (m *UsersMutation) Defense() (r int, exists bool) {
	v := m.defense
	if v == nil {
		return
	}
	return *v, true
}

// OldDefense returns the old "defense" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldDefense(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldDefense is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldDefense requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDefense: %w", err)
	}
	return oldValue.Defense, nil
}

// AddDefense adds i to the "defense" field.
func (m *UsersMutation) AddDefense(i int) {
	if m.adddefense != nil {
		*m.adddefense += i
	} else {
		m.adddefense = &i
	}
}

// AddedDefense returns the value that was added to the "defense" field in this mutation.
func (m *UsersMutation) AddedDefense() (r int, exists bool) {
	v := m.adddefense
	if v == nil {
		return
	}
	return *v, true
}

// ClearDefense clears the value of the "defense" field.
func (m *UsersMutation) ClearDefense() {
	m.defense = nil
	m.adddefense = nil
	m.clearedFields[users.FieldDefense] = struct{}{}
}

// DefenseCleared returns if the "defense" field was cleared in this mutation.
func (m *UsersMutation) DefenseCleared() bool {
	_, ok := m.clearedFields[users.FieldDefense]
	return ok
}

// ResetDefense resets all changes to the "defense" field.
func (m *UsersMutation) ResetDefense() {
	m.defense = nil
	m.adddefense = nil
	delete(m.clearedFields, users.FieldDefense)
}

// SetCritical sets the "critical" field.
func (m *UsersMutation) SetCritical(i int) {
	m.critical = &i
	m.addcritical = nil
}

// Critical returns the value of the "critical" field in the mutation.
func (m *UsersMutation) Critical() (r int, exists bool) {
	v := m.critical
	if v == nil {
		return
	}
	return *v, true
}

// OldCritical returns the old "critical" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldCritical(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCritical is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCritical requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCritical: %w", err)
	}
	return oldValue.Critical, nil
}

// AddCritical adds i to the "critical" field.
func (m *UsersMutation) AddCritical(i int) {
	if m.addcritical != nil {
		*m.addcritical += i
	} else {
		m.addcritical = &i
	}
}

// AddedCritical returns the value that was added to the "critical" field in this mutation.
func (m *UsersMutation) AddedCritical() (r int, exists bool) {
	v := m.addcritical
	if v == nil {
		return
	}
	return *v, true
}

// ClearCritical clears the value of the "critical" field.
func (m *UsersMutation) ClearCritical() {
	m.critical = nil
	m.addcritical = nil
	m.clearedFields[users.FieldCritical] = struct{}{}
}

// CriticalCleared returns if the "critical" field was cleared in this mutation.
func (m *UsersMutation) CriticalCleared() bool {
	_, ok := m.clearedFields[users.FieldCritical]
	return ok
}

// ResetCritical resets all changes to the "critical" field.
func (m *UsersMutation) ResetCritical() {
	m.critical = nil
	m.addcritical = nil
	delete(m.clearedFields, users.FieldCritical)
}

// SetBattle sets the "battle" field.
func (m *UsersMutation) SetBattle(i int) {
	m.battle = &i
	m.addbattle = nil
}

// Battle returns the value of the "battle" field in the mutation.
func (m *UsersMutation) Battle() (r int, exists bool) {
	v := m.battle
	if v == nil {
		return
	}
	return *v, true
}

// OldBattle returns the old "battle" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldBattle(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBattle is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBattle requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBattle: %w", err)
	}
	return oldValue.Battle, nil
}

// AddBattle adds i to the "battle" field.
func (m *UsersMutation) AddBattle(i int) {
	if m.addbattle != nil {
		*m.addbattle += i
	} else {
		m.addbattle = &i
	}
}

// AddedBattle returns the value that was added to the "battle" field in this mutation.
func (m *UsersMutation) AddedBattle() (r int, exists bool) {
	v := m.addbattle
	if v == nil {
		return
	}
	return *v, true
}

// ClearBattle clears the value of the "battle" field.
func (m *UsersMutation) ClearBattle() {
	m.battle = nil
	m.addbattle = nil
	m.clearedFields[users.FieldBattle] = struct{}{}
}

// BattleCleared returns if the "battle" field was cleared in this mutation.
func (m *UsersMutation) BattleCleared() bool {
	_, ok := m.clearedFields[users.FieldBattle]
	return ok
}

// ResetBattle resets all changes to the "battle" field.
func (m *UsersMutation) ResetBattle() {
	m.battle = nil
	m.addbattle = nil
	delete(m.clearedFields, users.FieldBattle)
}

// SetWin sets the "win" field.
func (m *UsersMutation) SetWin(i int) {
	m.win = &i
	m.addwin = nil
}

// Win returns the value of the "win" field in the mutation.
func (m *UsersMutation) Win() (r int, exists bool) {
	v := m.win
	if v == nil {
		return
	}
	return *v, true
}

// OldWin returns the old "win" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldWin(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWin is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWin requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWin: %w", err)
	}
	return oldValue.Win, nil
}

// AddWin adds i to the "win" field.
func (m *UsersMutation) AddWin(i int) {
	if m.addwin != nil {
		*m.addwin += i
	} else {
		m.addwin = &i
	}
}

// AddedWin returns the value that was added to the "win" field in this mutation.
func (m *UsersMutation) AddedWin() (r int, exists bool) {
	v := m.addwin
	if v == nil {
		return
	}
	return *v, true
}

// ClearWin clears the value of the "win" field.
func (m *UsersMutation) ClearWin() {
	m.win = nil
	m.addwin = nil
	m.clearedFields[users.FieldWin] = struct{}{}
}

// WinCleared returns if the "win" field was cleared in this mutation.
func (m *UsersMutation) WinCleared() bool {
	_, ok := m.clearedFields[users.FieldWin]
	return ok
}

// ResetWin resets all changes to the "win" field.
func (m *UsersMutation) ResetWin() {
	m.win = nil
	m.addwin = nil
	delete(m.clearedFields, users.FieldWin)
}

// SetDay sets the "day" field.
func (m *UsersMutation) SetDay(i int) {
	m.day = &i
	m.addday = nil
}

// Day returns the value of the "day" field in the mutation.
func (m *UsersMutation) Day() (r int, exists bool) {
	v := m.day
	if v == nil {
		return
	}
	return *v, true
}

// OldDay returns the old "day" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldDay(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldDay is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldDay requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDay: %w", err)
	}
	return oldValue.Day, nil
}

// AddDay adds i to the "day" field.
func (m *UsersMutation) AddDay(i int) {
	if m.addday != nil {
		*m.addday += i
	} else {
		m.addday = &i
	}
}

// AddedDay returns the value that was added to the "day" field in this mutation.
func (m *UsersMutation) AddedDay() (r int, exists bool) {
	v := m.addday
	if v == nil {
		return
	}
	return *v, true
}

// ClearDay clears the value of the "day" field.
func (m *UsersMutation) ClearDay() {
	m.day = nil
	m.addday = nil
	m.clearedFields[users.FieldDay] = struct{}{}
}

// DayCleared returns if the "day" field was cleared in this mutation.
func (m *UsersMutation) DayCleared() bool {
	_, ok := m.clearedFields[users.FieldDay]
	return ok
}

// ResetDay resets all changes to the "day" field.
func (m *UsersMutation) ResetDay() {
	m.day = nil
	m.addday = nil
	delete(m.clearedFields, users.FieldDay)
}

// SetPercentage sets the "percentage" field.
func (m *UsersMutation) SetPercentage(f float64) {
	m.percentage = &f
	m.addpercentage = nil
}

// Percentage returns the value of the "percentage" field in the mutation.
func (m *UsersMutation) Percentage() (r float64, exists bool) {
	v := m.percentage
	if v == nil {
		return
	}
	return *v, true
}

// OldPercentage returns the old "percentage" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldPercentage(ctx context.Context) (v float64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPercentage is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPercentage requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPercentage: %w", err)
	}
	return oldValue.Percentage, nil
}

// AddPercentage adds f to the "percentage" field.
func (m *UsersMutation) AddPercentage(f float64) {
	if m.addpercentage != nil {
		*m.addpercentage += f
	} else {
		m.addpercentage = &f
	}
}

// AddedPercentage returns the value that was added to the "percentage" field in this mutation.
func (m *UsersMutation) AddedPercentage() (r float64, exists bool) {
	v := m.addpercentage
	if v == nil {
		return
	}
	return *v, true
}

// ClearPercentage clears the value of the "percentage" field.
func (m *UsersMutation) ClearPercentage() {
	m.percentage = nil
	m.addpercentage = nil
	m.clearedFields[users.FieldPercentage] = struct{}{}
}

// PercentageCleared returns if the "percentage" field was cleared in this mutation.
func (m *UsersMutation) PercentageCleared() bool {
	_, ok := m.clearedFields[users.FieldPercentage]
	return ok
}

// ResetPercentage resets all changes to the "percentage" field.
func (m *UsersMutation) ResetPercentage() {
	m.percentage = nil
	m.addpercentage = nil
	delete(m.clearedFields, users.FieldPercentage)
}

// SetLimit sets the "limit" field.
func (m *UsersMutation) SetLimit(b bool) {
	m._limit = &b
}

// Limit returns the value of the "limit" field in the mutation.
func (m *UsersMutation) Limit() (r bool, exists bool) {
	v := m._limit
	if v == nil {
		return
	}
	return *v, true
}

// OldLimit returns the old "limit" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldLimit(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldLimit is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldLimit requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldLimit: %w", err)
	}
	return oldValue.Limit, nil
}

// ClearLimit clears the value of the "limit" field.
func (m *UsersMutation) ClearLimit() {
	m._limit = nil
	m.clearedFields[users.FieldLimit] = struct{}{}
}

// LimitCleared returns if the "limit" field was cleared in this mutation.
func (m *UsersMutation) LimitCleared() bool {
	_, ok := m.clearedFields[users.FieldLimit]
	return ok
}

// ResetLimit resets all changes to the "limit" field.
func (m *UsersMutation) ResetLimit() {
	m._limit = nil
	delete(m.clearedFields, users.FieldLimit)
}

// SetStatus sets the "status" field.
func (m *UsersMutation) SetStatus(s string) {
	m.status = &s
}

// Status returns the value of the "status" field in the mutation.
func (m *UsersMutation) Status() (r string, exists bool) {
	v := m.status
	if v == nil {
		return
	}
	return *v, true
}

// OldStatus returns the old "status" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldStatus(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStatus requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
	}
	return oldValue.Status, nil
}

// ClearStatus clears the value of the "status" field.
func (m *UsersMutation) ClearStatus() {
	m.status = nil
	m.clearedFields[users.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *UsersMutation) StatusCleared() bool {
	_, ok := m.clearedFields[users.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *UsersMutation) ResetStatus() {
	m.status = nil
	delete(m.clearedFields, users.FieldStatus)
}

// SetComment sets the "comment" field.
func (m *UsersMutation) SetComment(s string) {
	m.comment = &s
}

// Comment returns the value of the "comment" field in the mutation.
func (m *UsersMutation) Comment() (r string, exists bool) {
	v := m.comment
	if v == nil {
		return
	}
	return *v, true
}

// OldComment returns the old "comment" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldComment(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldComment is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldComment requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldComment: %w", err)
	}
	return oldValue.Comment, nil
}

// ClearComment clears the value of the "comment" field.
func (m *UsersMutation) ClearComment() {
	m.comment = nil
	m.clearedFields[users.FieldComment] = struct{}{}
}

// CommentCleared returns if the "comment" field was cleared in this mutation.
func (m *UsersMutation) CommentCleared() bool {
	_, ok := m.clearedFields[users.FieldComment]
	return ok
}

// ResetComment resets all changes to the "comment" field.
func (m *UsersMutation) ResetComment() {
	m.comment = nil
	delete(m.clearedFields, users.FieldComment)
}

// SetCreatedAt sets the "created_at" field.
func (m *UsersMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsersMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ClearCreatedAt clears the value of the "created_at" field.
func (m *UsersMutation) ClearCreatedAt() {
	m.created_at = nil
	m.clearedFields[users.FieldCreatedAt] = struct{}{}
}

// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
func (m *UsersMutation) CreatedAtCleared() bool {
	_, ok := m.clearedFields[users.FieldCreatedAt]
	return ok
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *UsersMutation) ResetCreatedAt() {
	m.created_at = nil
	delete(m.clearedFields, users.FieldCreatedAt)
}

// SetNext sets the "next" field.
func (m *UsersMutation) SetNext(s string) {
	m.next = &s
}

// Next returns the value of the "next" field in the mutation.
func (m *UsersMutation) Next() (r string, exists bool) {
	v := m.next
	if v == nil {
		return
	}
	return *v, true
}

// OldNext returns the old "next" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldNext(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNext is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNext requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNext: %w", err)
	}
	return oldValue.Next, nil
}

// ClearNext clears the value of the "next" field.
func (m *UsersMutation) ClearNext() {
	m.next = nil
	m.clearedFields[users.FieldNext] = struct{}{}
}

// NextCleared returns if the "next" field was cleared in this mutation.
func (m *UsersMutation) NextCleared() bool {
	_, ok := m.clearedFields[users.FieldNext]
	return ok
}

// ResetNext resets all changes to the "next" field.
func (m *UsersMutation) ResetNext() {
	m.next = nil
	delete(m.clearedFields, users.FieldNext)
}

// SetUpdatedAt sets the "updated_at" field.
func (m *UsersMutation) SetUpdatedAt(t time.Time) {
	m.updated_at = &t
}

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsersMutation) UpdatedAt() (r time.Time, exists bool) {
	v := m.updated_at
	if v == nil {
		return
	}
	return *v, true
}

// OldUpdatedAt returns the old "updated_at" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
	}
	return oldValue.UpdatedAt, nil
}

// ClearUpdatedAt clears the value of the "updated_at" field.
func (m *UsersMutation) ClearUpdatedAt() {
	m.updated_at = nil
	m.clearedFields[users.FieldUpdatedAt] = struct{}{}
}

// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
func (m *UsersMutation) UpdatedAtCleared() bool {
	_, ok := m.clearedFields[users.FieldUpdatedAt]
	return ok
}

// ResetUpdatedAt resets all changes to the "updated_at" field.
func (m *UsersMutation) ResetUpdatedAt() {
	m.updated_at = nil
	delete(m.clearedFields, users.FieldUpdatedAt)
}

// SetURL sets the "url" field.
func (m *UsersMutation) SetURL(s string) {
	m.url = &s
}

// URL returns the value of the "url" field in the mutation.
func (m *UsersMutation) URL() (r string, exists bool) {
	v := m.url
	if v == nil {
		return
	}
	return *v, true
}

// OldURL returns the old "url" field's value of the Users entity.
// If the Users object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsersMutation) OldURL(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldURL is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldURL requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldURL: %w", err)
	}
	return oldValue.URL, nil
}

// ClearURL clears the value of the "url" field.
func (m *UsersMutation) ClearURL() {
	m.url = nil
	m.clearedFields[users.FieldURL] = struct{}{}
}

// URLCleared returns if the "url" field was cleared in this mutation.
func (m *UsersMutation) URLCleared() bool {
	_, ok := m.clearedFields[users.FieldURL]
	return ok
}

// ResetURL resets all changes to the "url" field.
func (m *UsersMutation) ResetURL() {
	m.url = nil
	delete(m.clearedFields, users.FieldURL)
}

// Where appends a list predicates to the UsersMutation builder.
func (m *UsersMutation) Where(ps ...predicate.Users) {
	m.predicates = append(m.predicates, ps...)
}

// Op returns the operation name.
func (m *UsersMutation) Op() Op {
	return m.op
}

// Type returns the node type of this mutation (Users).
func (m *UsersMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *UsersMutation) Fields() []string {
	fields := make([]string, 0, 18)
	if m.user != nil {
		fields = append(fields, users.FieldUser)
	}
	if m.chara != nil {
		fields = append(fields, users.FieldChara)
	}
	if m.skill != nil {
		fields = append(fields, users.FieldSkill)
	}
	if m.hp != nil {
		fields = append(fields, users.FieldHp)
	}
	if m.attack != nil {
		fields = append(fields, users.FieldAttack)
	}
	if m.defense != nil {
		fields = append(fields, users.FieldDefense)
	}
	if m.critical != nil {
		fields = append(fields, users.FieldCritical)
	}
	if m.battle != nil {
		fields = append(fields, users.FieldBattle)
	}
	if m.win != nil {
		fields = append(fields, users.FieldWin)
	}
	if m.day != nil {
		fields = append(fields, users.FieldDay)
	}
	if m.percentage != nil {
		fields = append(fields, users.FieldPercentage)
	}
	if m._limit != nil {
		fields = append(fields, users.FieldLimit)
	}
	if m.status != nil {
		fields = append(fields, users.FieldStatus)
	}
	if m.comment != nil {
		fields = append(fields, users.FieldComment)
	}
	if m.created_at != nil {
		fields = append(fields, users.FieldCreatedAt)
	}
	if m.next != nil {
		fields = append(fields, users.FieldNext)
	}
	if m.updated_at != nil {
		fields = append(fields, users.FieldUpdatedAt)
	}
	if m.url != nil {
		fields = append(fields, users.FieldURL)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *UsersMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case users.FieldUser:
		return m.User()
	case users.FieldChara:
		return m.Chara()
	case users.FieldSkill:
		return m.Skill()
	case users.FieldHp:
		return m.Hp()
	case users.FieldAttack:
		return m.Attack()
	case users.FieldDefense:
		return m.Defense()
	case users.FieldCritical:
		return m.Critical()
	case users.FieldBattle:
		return m.Battle()
	case users.FieldWin:
		return m.Win()
	case users.FieldDay:
		return m.Day()
	case users.FieldPercentage:
		return m.Percentage()
	case users.FieldLimit:
		return m.Limit()
	case users.FieldStatus:
		return m.Status()
	case users.FieldComment:
		return m.Comment()
	case users.FieldCreatedAt:
		return m.CreatedAt()
	case users.FieldNext:
		return m.Next()
	case users.FieldUpdatedAt:
		return m.UpdatedAt()
	case users.FieldURL:
		return m.URL()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *UsersMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case users.FieldUser:
		return m.OldUser(ctx)
	case users.FieldChara:
		return m.OldChara(ctx)
	case users.FieldSkill:
		return m.OldSkill(ctx)
	case users.FieldHp:
		return m.OldHp(ctx)
	case users.FieldAttack:
		return m.OldAttack(ctx)
	case users.FieldDefense:
		return m.OldDefense(ctx)
	case users.FieldCritical:
		return m.OldCritical(ctx)
	case users.FieldBattle:
		return m.OldBattle(ctx)
	case users.FieldWin:
		return m.OldWin(ctx)
	case users.FieldDay:
		return m.OldDay(ctx)
	case users.FieldPercentage:
		return m.OldPercentage(ctx)
	case users.FieldLimit:
		return m.OldLimit(ctx)
	case users.FieldStatus:
		return m.OldStatus(ctx)
	case users.FieldComment:
		return m.OldComment(ctx)
	case users.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case users.FieldNext:
		return m.OldNext(ctx)
	case users.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case users.FieldURL:
		return m.OldURL(ctx)
	}
	return nil, fmt.Errorf("unknown Users field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *UsersMutation) SetField(name string, value ent.Value) error {
	switch name {
	case users.FieldUser:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUser(v)
		return nil
	case users.FieldChara:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChara(v)
		return nil
	case users.FieldSkill:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSkill(v)
		return nil
	case users.FieldHp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHp(v)
		return nil
	case users.FieldAttack:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAttack(v)
		return nil
	case users.FieldDefense:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDefense(v)
		return nil
	case users.FieldCritical:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCritical(v)
		return nil
	case users.FieldBattle:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBattle(v)
		return nil
	case users.FieldWin:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWin(v)
		return nil
	case users.FieldDay:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDay(v)
		return nil
	case users.FieldPercentage:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPercentage(v)
		return nil
	case users.FieldLimit:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLimit(v)
		return nil
	case users.FieldStatus:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case users.FieldComment:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetComment(v)
		return nil
	case users.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case users.FieldNext:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNext(v)
		return nil
	case users.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case users.FieldURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetURL(v)
		return nil
	}
	return fmt.Errorf("unknown Users field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsersMutation) AddedFields() []string {
	var fields []string
	if m.addskill != nil {
		fields = append(fields, users.FieldSkill)
	}
	if m.addhp != nil {
		fields = append(fields, users.FieldHp)
	}
	if m.addattack != nil {
		fields = append(fields, users.FieldAttack)
	}
	if m.adddefense != nil {
		fields = append(fields, users.FieldDefense)
	}
	if m.addcritical != nil {
		fields = append(fields, users.FieldCritical)
	}
	if m.addbattle != nil {
		fields = append(fields, users.FieldBattle)
	}
	if m.addwin != nil {
		fields = append(fields, users.FieldWin)
	}
	if m.addday != nil {
		fields = append(fields, users.FieldDay)
	}
	if m.addpercentage != nil {
		fields = append(fields, users.FieldPercentage)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *UsersMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case users.FieldSkill:
		return m.AddedSkill()
	case users.FieldHp:
		return m.AddedHp()
	case users.FieldAttack:
		return m.AddedAttack()
	case users.FieldDefense:
		return m.AddedDefense()
	case users.FieldCritical:
		return m.AddedCritical()
	case users.FieldBattle:
		return m.AddedBattle()
	case users.FieldWin:
		return m.AddedWin()
	case users.FieldDay:
		return m.AddedDay()
	case users.FieldPercentage:
		return m.AddedPercentage()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *UsersMutation) AddField(name string, value ent.Value) error {
	switch name {
	case users.FieldSkill:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSkill(v)
		return nil
	case users.FieldHp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddHp(v)
		return nil
	case users.FieldAttack:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAttack(v)
		return nil
	case users.FieldDefense:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDefense(v)
		return nil
	case users.FieldCritical:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCritical(v)
		return nil
	case users.FieldBattle:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBattle(v)
		return nil
	case users.FieldWin:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddWin(v)
		return nil
	case users.FieldDay:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDay(v)
		return nil
	case users.FieldPercentage:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPercentage(v)
		return nil
	}
	return fmt.Errorf("unknown Users numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *UsersMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(users.FieldChara) {
		fields = append(fields, users.FieldChara)
	}
	if m.FieldCleared(users.FieldSkill) {
		fields = append(fields, users.FieldSkill)
	}
	if m.FieldCleared(users.FieldHp) {
		fields = append(fields, users.FieldHp)
	}
	if m.FieldCleared(users.FieldAttack) {
		fields = append(fields, users.FieldAttack)
	}
	if m.FieldCleared(users.FieldDefense) {
		fields = append(fields, users.FieldDefense)
	}
	if m.FieldCleared(users.FieldCritical) {
		fields = append(fields, users.FieldCritical)
	}
	if m.FieldCleared(users.FieldBattle) {
		fields = append(fields, users.FieldBattle)
	}
	if m.FieldCleared(users.FieldWin) {
		fields = append(fields, users.FieldWin)
	}
	if m.FieldCleared(users.FieldDay) {
		fields = append(fields, users.FieldDay)
	}
	if m.FieldCleared(users.FieldPercentage) {
		fields = append(fields, users.FieldPercentage)
	}
	if m.FieldCleared(users.FieldLimit) {
		fields = append(fields, users.FieldLimit)
	}
	if m.FieldCleared(users.FieldStatus) {
		fields = append(fields, users.FieldStatus)
	}
	if m.FieldCleared(users.FieldComment) {
		fields = append(fields, users.FieldComment)
	}
	if m.FieldCleared(users.FieldCreatedAt) {
		fields = append(fields, users.FieldCreatedAt)
	}
	if m.FieldCleared(users.FieldNext) {
		fields = append(fields, users.FieldNext)
	}
	if m.FieldCleared(users.FieldUpdatedAt) {
		fields = append(fields, users.FieldUpdatedAt)
	}
	if m.FieldCleared(users.FieldURL) {
		fields = append(fields, users.FieldURL)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsersMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *UsersMutation) ClearField(name string) error {
	switch name {
	case users.FieldChara:
		m.ClearChara()
		return nil
	case users.FieldSkill:
		m.ClearSkill()
		return nil
	case users.FieldHp:
		m.ClearHp()
		return nil
	case users.FieldAttack:
		m.ClearAttack()
		return nil
	case users.FieldDefense:
		m.ClearDefense()
		return nil
	case users.FieldCritical:
		m.ClearCritical()
		return nil
	case users.FieldBattle:
		m.ClearBattle()
		return nil
	case users.FieldWin:
		m.ClearWin()
		return nil
	case users.FieldDay:
		m.ClearDay()
		return nil
	case users.FieldPercentage:
		m.ClearPercentage()
		return nil
	case users.FieldLimit:
		m.ClearLimit()
		return nil
	case users.FieldStatus:
		m.ClearStatus()
		return nil
	case users.FieldComment:
		m.ClearComment()
		return nil
	case users.FieldCreatedAt:
		m.ClearCreatedAt()
		return nil
	case users.FieldNext:
		m.ClearNext()
		return nil
	case users.FieldUpdatedAt:
		m.ClearUpdatedAt()
		return nil
	case users.FieldURL:
		m.ClearURL()
		return nil
	}
	return fmt.Errorf("unknown Users nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *UsersMutation) ResetField(name string) error {
	switch name {
	case users.FieldUser:
		m.ResetUser()
		return nil
	case users.FieldChara:
		m.ResetChara()
		return nil
	case users.FieldSkill:
		m.ResetSkill()
		return nil
	case users.FieldHp:
		m.ResetHp()
		return nil
	case users.FieldAttack:
		m.ResetAttack()
		return nil
	case users.FieldDefense:
		m.ResetDefense()
		return nil
	case users.FieldCritical:
		m.ResetCritical()
		return nil
	case users.FieldBattle:
		m.ResetBattle()
		return nil
	case users.FieldWin:
		m.ResetWin()
		return nil
	case users.FieldDay:
		m.ResetDay()
		return nil
	case users.FieldPercentage:
		m.ResetPercentage()
		return nil
	case users.FieldLimit:
		m.ResetLimit()
		return nil
	case users.FieldStatus:
		m.ResetStatus()
		return nil
	case users.FieldComment:
		m.ResetComment()
		return nil
	case users.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case users.FieldNext:
		m.ResetNext()
		return nil
	case users.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case users.FieldURL:
		m.ResetURL()
		return nil
	}
	return fmt.Errorf("unknown Users field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *UsersMutation) AddedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *UsersMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *UsersMutation) RemovedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *UsersMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *UsersMutation) ClearedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *UsersMutation) EdgeCleared(name string) bool {
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *UsersMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Users unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *UsersMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Users edge %s", name)
}