// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"csgowtfd/ent/match"
	"csgowtfd/ent/player"
	"csgowtfd/ent/predicate"
	"csgowtfd/ent/stats"
	"fmt"
	"sync"
	"time"

	"entgo.io/ent"
)

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

	// Node types.
	TypeMatch  = "Match"
	TypePlayer = "Player"
	TypeStats  = "Stats"
)

// MatchMutation represents an operation that mutates the Match nodes in the graph.
type MatchMutation struct {
	config
	op              Op
	typ             string
	id              *int
	match_id        *uint64
	addmatch_id     *uint64
	share_code      *string
	_map            *string
	date            *time.Time
	score_team_a    *int
	addscore_team_a *int
	score_team_b    *int
	addscore_team_b *int
	replay_url      *string
	duration        *int
	addduration     *int
	match_result    *int
	addmatch_result *int
	max_rounds      *int
	addmax_rounds   *int
	demo_expired    *bool
	demo_parsed     *bool
	eco             *struct {
		Rounds []*struct {
			Team      int "json:\"team\""
			Bank      int "json:\"bank\""
			Equipment int "json:\"equipment\""
		} "json:\"rounds\""
	}
	clearedFields  map[string]struct{}
	stats          map[int]struct{}
	removedstats   map[int]struct{}
	clearedstats   bool
	players        map[int]struct{}
	removedplayers map[int]struct{}
	clearedplayers bool
	done           bool
	oldValue       func(context.Context) (*Match, error)
	predicates     []predicate.Match
}

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

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

// newMatchMutation creates new mutation for the Match entity.
func newMatchMutation(c config, op Op, opts ...matchOption) *MatchMutation {
	m := &MatchMutation{
		config:        c,
		op:            op,
		typ:           TypeMatch,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withMatchID sets the ID field of the mutation.
func withMatchID(id int) matchOption {
	return func(m *MatchMutation) {
		var (
			err   error
			once  sync.Once
			value *Match
		)
		m.oldValue = func(ctx context.Context) (*Match, error) {
			once.Do(func() {
				if m.done {
					err = fmt.Errorf("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Match.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withMatch sets the old Match of the mutation.
func withMatch(node *Match) matchOption {
	return func(m *MatchMutation) {
		m.oldValue = func(context.Context) (*Match, 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 MatchMutation) 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 MatchMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, fmt.Errorf("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 *MatchMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// SetMatchID sets the "match_id" field.
func (m *MatchMutation) SetMatchID(u uint64) {
	m.match_id = &u
	m.addmatch_id = nil
}

// MatchID returns the value of the "match_id" field in the mutation.
func (m *MatchMutation) MatchID() (r uint64, exists bool) {
	v := m.match_id
	if v == nil {
		return
	}
	return *v, true
}

// OldMatchID returns the old "match_id" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldMatchID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldMatchID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldMatchID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMatchID: %w", err)
	}
	return oldValue.MatchID, nil
}

// AddMatchID adds u to the "match_id" field.
func (m *MatchMutation) AddMatchID(u uint64) {
	if m.addmatch_id != nil {
		*m.addmatch_id += u
	} else {
		m.addmatch_id = &u
	}
}

// AddedMatchID returns the value that was added to the "match_id" field in this mutation.
func (m *MatchMutation) AddedMatchID() (r uint64, exists bool) {
	v := m.addmatch_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetMatchID resets all changes to the "match_id" field.
func (m *MatchMutation) ResetMatchID() {
	m.match_id = nil
	m.addmatch_id = nil
}

// SetShareCode sets the "share_code" field.
func (m *MatchMutation) SetShareCode(s string) {
	m.share_code = &s
}

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

// OldShareCode returns the old "share_code" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldShareCode(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldShareCode is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldShareCode requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldShareCode: %w", err)
	}
	return oldValue.ShareCode, nil
}

// ResetShareCode resets all changes to the "share_code" field.
func (m *MatchMutation) ResetShareCode() {
	m.share_code = nil
}

// SetMap sets the "map" field.
func (m *MatchMutation) SetMap(s string) {
	m._map = &s
}

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

// OldMap returns the old "map" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldMap(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldMap is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldMap requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMap: %w", err)
	}
	return oldValue.Map, nil
}

// ClearMap clears the value of the "map" field.
func (m *MatchMutation) ClearMap() {
	m._map = nil
	m.clearedFields[match.FieldMap] = struct{}{}
}

// MapCleared returns if the "map" field was cleared in this mutation.
func (m *MatchMutation) MapCleared() bool {
	_, ok := m.clearedFields[match.FieldMap]
	return ok
}

// ResetMap resets all changes to the "map" field.
func (m *MatchMutation) ResetMap() {
	m._map = nil
	delete(m.clearedFields, match.FieldMap)
}

// SetDate sets the "date" field.
func (m *MatchMutation) SetDate(t time.Time) {
	m.date = &t
}

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

// OldDate returns the old "date" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldDate(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldDate is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldDate requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDate: %w", err)
	}
	return oldValue.Date, nil
}

// ResetDate resets all changes to the "date" field.
func (m *MatchMutation) ResetDate() {
	m.date = nil
}

// SetScoreTeamA sets the "score_team_a" field.
func (m *MatchMutation) SetScoreTeamA(i int) {
	m.score_team_a = &i
	m.addscore_team_a = nil
}

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

// OldScoreTeamA returns the old "score_team_a" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldScoreTeamA(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldScoreTeamA is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldScoreTeamA requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldScoreTeamA: %w", err)
	}
	return oldValue.ScoreTeamA, nil
}

// AddScoreTeamA adds i to the "score_team_a" field.
func (m *MatchMutation) AddScoreTeamA(i int) {
	if m.addscore_team_a != nil {
		*m.addscore_team_a += i
	} else {
		m.addscore_team_a = &i
	}
}

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

// ResetScoreTeamA resets all changes to the "score_team_a" field.
func (m *MatchMutation) ResetScoreTeamA() {
	m.score_team_a = nil
	m.addscore_team_a = nil
}

// SetScoreTeamB sets the "score_team_b" field.
func (m *MatchMutation) SetScoreTeamB(i int) {
	m.score_team_b = &i
	m.addscore_team_b = nil
}

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

// OldScoreTeamB returns the old "score_team_b" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldScoreTeamB(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldScoreTeamB is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldScoreTeamB requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldScoreTeamB: %w", err)
	}
	return oldValue.ScoreTeamB, nil
}

// AddScoreTeamB adds i to the "score_team_b" field.
func (m *MatchMutation) AddScoreTeamB(i int) {
	if m.addscore_team_b != nil {
		*m.addscore_team_b += i
	} else {
		m.addscore_team_b = &i
	}
}

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

// ResetScoreTeamB resets all changes to the "score_team_b" field.
func (m *MatchMutation) ResetScoreTeamB() {
	m.score_team_b = nil
	m.addscore_team_b = nil
}

// SetReplayURL sets the "replay_url" field.
func (m *MatchMutation) SetReplayURL(s string) {
	m.replay_url = &s
}

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

// OldReplayURL returns the old "replay_url" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldReplayURL(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldReplayURL is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldReplayURL requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldReplayURL: %w", err)
	}
	return oldValue.ReplayURL, nil
}

// ClearReplayURL clears the value of the "replay_url" field.
func (m *MatchMutation) ClearReplayURL() {
	m.replay_url = nil
	m.clearedFields[match.FieldReplayURL] = struct{}{}
}

// ReplayURLCleared returns if the "replay_url" field was cleared in this mutation.
func (m *MatchMutation) ReplayURLCleared() bool {
	_, ok := m.clearedFields[match.FieldReplayURL]
	return ok
}

// ResetReplayURL resets all changes to the "replay_url" field.
func (m *MatchMutation) ResetReplayURL() {
	m.replay_url = nil
	delete(m.clearedFields, match.FieldReplayURL)
}

// SetDuration sets the "duration" field.
func (m *MatchMutation) SetDuration(i int) {
	m.duration = &i
	m.addduration = nil
}

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

// OldDuration returns the old "duration" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldDuration(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldDuration is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldDuration requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDuration: %w", err)
	}
	return oldValue.Duration, nil
}

// AddDuration adds i to the "duration" field.
func (m *MatchMutation) AddDuration(i int) {
	if m.addduration != nil {
		*m.addduration += i
	} else {
		m.addduration = &i
	}
}

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

// ResetDuration resets all changes to the "duration" field.
func (m *MatchMutation) ResetDuration() {
	m.duration = nil
	m.addduration = nil
}

// SetMatchResult sets the "match_result" field.
func (m *MatchMutation) SetMatchResult(i int) {
	m.match_result = &i
	m.addmatch_result = nil
}

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

// OldMatchResult returns the old "match_result" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldMatchResult(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldMatchResult is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldMatchResult requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMatchResult: %w", err)
	}
	return oldValue.MatchResult, nil
}

// AddMatchResult adds i to the "match_result" field.
func (m *MatchMutation) AddMatchResult(i int) {
	if m.addmatch_result != nil {
		*m.addmatch_result += i
	} else {
		m.addmatch_result = &i
	}
}

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

// ResetMatchResult resets all changes to the "match_result" field.
func (m *MatchMutation) ResetMatchResult() {
	m.match_result = nil
	m.addmatch_result = nil
}

// SetMaxRounds sets the "max_rounds" field.
func (m *MatchMutation) SetMaxRounds(i int) {
	m.max_rounds = &i
	m.addmax_rounds = nil
}

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

// OldMaxRounds returns the old "max_rounds" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldMaxRounds(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldMaxRounds is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldMaxRounds requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMaxRounds: %w", err)
	}
	return oldValue.MaxRounds, nil
}

// AddMaxRounds adds i to the "max_rounds" field.
func (m *MatchMutation) AddMaxRounds(i int) {
	if m.addmax_rounds != nil {
		*m.addmax_rounds += i
	} else {
		m.addmax_rounds = &i
	}
}

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

// ResetMaxRounds resets all changes to the "max_rounds" field.
func (m *MatchMutation) ResetMaxRounds() {
	m.max_rounds = nil
	m.addmax_rounds = nil
}

// SetDemoExpired sets the "demo_expired" field.
func (m *MatchMutation) SetDemoExpired(b bool) {
	m.demo_expired = &b
}

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

// OldDemoExpired returns the old "demo_expired" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldDemoExpired(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldDemoExpired is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldDemoExpired requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDemoExpired: %w", err)
	}
	return oldValue.DemoExpired, nil
}

// ResetDemoExpired resets all changes to the "demo_expired" field.
func (m *MatchMutation) ResetDemoExpired() {
	m.demo_expired = nil
}

// SetDemoParsed sets the "demo_parsed" field.
func (m *MatchMutation) SetDemoParsed(b bool) {
	m.demo_parsed = &b
}

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

// OldDemoParsed returns the old "demo_parsed" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldDemoParsed(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldDemoParsed is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldDemoParsed requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDemoParsed: %w", err)
	}
	return oldValue.DemoParsed, nil
}

// ResetDemoParsed resets all changes to the "demo_parsed" field.
func (m *MatchMutation) ResetDemoParsed() {
	m.demo_parsed = nil
}

// SetEco sets the "eco" field.
func (m *MatchMutation) SetEco(s struct {
	Rounds []*struct {
		Team      int "json:\"team\""
		Bank      int "json:\"bank\""
		Equipment int "json:\"equipment\""
	} "json:\"rounds\""
}) {
	m.eco = &s
}

// Eco returns the value of the "eco" field in the mutation.
func (m *MatchMutation) Eco() (r struct {
	Rounds []*struct {
		Team      int "json:\"team\""
		Bank      int "json:\"bank\""
		Equipment int "json:\"equipment\""
	} "json:\"rounds\""
}, exists bool) {
	v := m.eco
	if v == nil {
		return
	}
	return *v, true
}

// OldEco returns the old "eco" field's value of the Match entity.
// If the Match 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 *MatchMutation) OldEco(ctx context.Context) (v struct {
	Rounds []*struct {
		Team      int "json:\"team\""
		Bank      int "json:\"bank\""
		Equipment int "json:\"equipment\""
	} "json:\"rounds\""
}, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldEco is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldEco requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldEco: %w", err)
	}
	return oldValue.Eco, nil
}

// ClearEco clears the value of the "eco" field.
func (m *MatchMutation) ClearEco() {
	m.eco = nil
	m.clearedFields[match.FieldEco] = struct{}{}
}

// EcoCleared returns if the "eco" field was cleared in this mutation.
func (m *MatchMutation) EcoCleared() bool {
	_, ok := m.clearedFields[match.FieldEco]
	return ok
}

// ResetEco resets all changes to the "eco" field.
func (m *MatchMutation) ResetEco() {
	m.eco = nil
	delete(m.clearedFields, match.FieldEco)
}

// AddStatIDs adds the "stats" edge to the Stats entity by ids.
func (m *MatchMutation) AddStatIDs(ids ...int) {
	if m.stats == nil {
		m.stats = make(map[int]struct{})
	}
	for i := range ids {
		m.stats[ids[i]] = struct{}{}
	}
}

// ClearStats clears the "stats" edge to the Stats entity.
func (m *MatchMutation) ClearStats() {
	m.clearedstats = true
}

// StatsCleared reports if the "stats" edge to the Stats entity was cleared.
func (m *MatchMutation) StatsCleared() bool {
	return m.clearedstats
}

// RemoveStatIDs removes the "stats" edge to the Stats entity by IDs.
func (m *MatchMutation) RemoveStatIDs(ids ...int) {
	if m.removedstats == nil {
		m.removedstats = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.stats, ids[i])
		m.removedstats[ids[i]] = struct{}{}
	}
}

// RemovedStats returns the removed IDs of the "stats" edge to the Stats entity.
func (m *MatchMutation) RemovedStatsIDs() (ids []int) {
	for id := range m.removedstats {
		ids = append(ids, id)
	}
	return
}

// StatsIDs returns the "stats" edge IDs in the mutation.
func (m *MatchMutation) StatsIDs() (ids []int) {
	for id := range m.stats {
		ids = append(ids, id)
	}
	return
}

// ResetStats resets all changes to the "stats" edge.
func (m *MatchMutation) ResetStats() {
	m.stats = nil
	m.clearedstats = false
	m.removedstats = nil
}

// AddPlayerIDs adds the "players" edge to the Player entity by ids.
func (m *MatchMutation) AddPlayerIDs(ids ...int) {
	if m.players == nil {
		m.players = make(map[int]struct{})
	}
	for i := range ids {
		m.players[ids[i]] = struct{}{}
	}
}

// ClearPlayers clears the "players" edge to the Player entity.
func (m *MatchMutation) ClearPlayers() {
	m.clearedplayers = true
}

// PlayersCleared reports if the "players" edge to the Player entity was cleared.
func (m *MatchMutation) PlayersCleared() bool {
	return m.clearedplayers
}

// RemovePlayerIDs removes the "players" edge to the Player entity by IDs.
func (m *MatchMutation) RemovePlayerIDs(ids ...int) {
	if m.removedplayers == nil {
		m.removedplayers = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.players, ids[i])
		m.removedplayers[ids[i]] = struct{}{}
	}
}

// RemovedPlayers returns the removed IDs of the "players" edge to the Player entity.
func (m *MatchMutation) RemovedPlayersIDs() (ids []int) {
	for id := range m.removedplayers {
		ids = append(ids, id)
	}
	return
}

// PlayersIDs returns the "players" edge IDs in the mutation.
func (m *MatchMutation) PlayersIDs() (ids []int) {
	for id := range m.players {
		ids = append(ids, id)
	}
	return
}

// ResetPlayers resets all changes to the "players" edge.
func (m *MatchMutation) ResetPlayers() {
	m.players = nil
	m.clearedplayers = false
	m.removedplayers = nil
}

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

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

// Type returns the node type of this mutation (Match).
func (m *MatchMutation) 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 *MatchMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.match_id != nil {
		fields = append(fields, match.FieldMatchID)
	}
	if m.share_code != nil {
		fields = append(fields, match.FieldShareCode)
	}
	if m._map != nil {
		fields = append(fields, match.FieldMap)
	}
	if m.date != nil {
		fields = append(fields, match.FieldDate)
	}
	if m.score_team_a != nil {
		fields = append(fields, match.FieldScoreTeamA)
	}
	if m.score_team_b != nil {
		fields = append(fields, match.FieldScoreTeamB)
	}
	if m.replay_url != nil {
		fields = append(fields, match.FieldReplayURL)
	}
	if m.duration != nil {
		fields = append(fields, match.FieldDuration)
	}
	if m.match_result != nil {
		fields = append(fields, match.FieldMatchResult)
	}
	if m.max_rounds != nil {
		fields = append(fields, match.FieldMaxRounds)
	}
	if m.demo_expired != nil {
		fields = append(fields, match.FieldDemoExpired)
	}
	if m.demo_parsed != nil {
		fields = append(fields, match.FieldDemoParsed)
	}
	if m.eco != nil {
		fields = append(fields, match.FieldEco)
	}
	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 *MatchMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case match.FieldMatchID:
		return m.MatchID()
	case match.FieldShareCode:
		return m.ShareCode()
	case match.FieldMap:
		return m.Map()
	case match.FieldDate:
		return m.Date()
	case match.FieldScoreTeamA:
		return m.ScoreTeamA()
	case match.FieldScoreTeamB:
		return m.ScoreTeamB()
	case match.FieldReplayURL:
		return m.ReplayURL()
	case match.FieldDuration:
		return m.Duration()
	case match.FieldMatchResult:
		return m.MatchResult()
	case match.FieldMaxRounds:
		return m.MaxRounds()
	case match.FieldDemoExpired:
		return m.DemoExpired()
	case match.FieldDemoParsed:
		return m.DemoParsed()
	case match.FieldEco:
		return m.Eco()
	}
	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 *MatchMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case match.FieldMatchID:
		return m.OldMatchID(ctx)
	case match.FieldShareCode:
		return m.OldShareCode(ctx)
	case match.FieldMap:
		return m.OldMap(ctx)
	case match.FieldDate:
		return m.OldDate(ctx)
	case match.FieldScoreTeamA:
		return m.OldScoreTeamA(ctx)
	case match.FieldScoreTeamB:
		return m.OldScoreTeamB(ctx)
	case match.FieldReplayURL:
		return m.OldReplayURL(ctx)
	case match.FieldDuration:
		return m.OldDuration(ctx)
	case match.FieldMatchResult:
		return m.OldMatchResult(ctx)
	case match.FieldMaxRounds:
		return m.OldMaxRounds(ctx)
	case match.FieldDemoExpired:
		return m.OldDemoExpired(ctx)
	case match.FieldDemoParsed:
		return m.OldDemoParsed(ctx)
	case match.FieldEco:
		return m.OldEco(ctx)
	}
	return nil, fmt.Errorf("unknown Match 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 *MatchMutation) SetField(name string, value ent.Value) error {
	switch name {
	case match.FieldMatchID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMatchID(v)
		return nil
	case match.FieldShareCode:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetShareCode(v)
		return nil
	case match.FieldMap:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMap(v)
		return nil
	case match.FieldDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDate(v)
		return nil
	case match.FieldScoreTeamA:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetScoreTeamA(v)
		return nil
	case match.FieldScoreTeamB:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetScoreTeamB(v)
		return nil
	case match.FieldReplayURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReplayURL(v)
		return nil
	case match.FieldDuration:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDuration(v)
		return nil
	case match.FieldMatchResult:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMatchResult(v)
		return nil
	case match.FieldMaxRounds:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMaxRounds(v)
		return nil
	case match.FieldDemoExpired:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDemoExpired(v)
		return nil
	case match.FieldDemoParsed:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDemoParsed(v)
		return nil
	case match.FieldEco:
		v, ok := value.(struct {
			Rounds []*struct {
				Team      int "json:\"team\""
				Bank      int "json:\"bank\""
				Equipment int "json:\"equipment\""
			} "json:\"rounds\""
		})
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEco(v)
		return nil
	}
	return fmt.Errorf("unknown Match field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *MatchMutation) AddedFields() []string {
	var fields []string
	if m.addmatch_id != nil {
		fields = append(fields, match.FieldMatchID)
	}
	if m.addscore_team_a != nil {
		fields = append(fields, match.FieldScoreTeamA)
	}
	if m.addscore_team_b != nil {
		fields = append(fields, match.FieldScoreTeamB)
	}
	if m.addduration != nil {
		fields = append(fields, match.FieldDuration)
	}
	if m.addmatch_result != nil {
		fields = append(fields, match.FieldMatchResult)
	}
	if m.addmax_rounds != nil {
		fields = append(fields, match.FieldMaxRounds)
	}
	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 *MatchMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case match.FieldMatchID:
		return m.AddedMatchID()
	case match.FieldScoreTeamA:
		return m.AddedScoreTeamA()
	case match.FieldScoreTeamB:
		return m.AddedScoreTeamB()
	case match.FieldDuration:
		return m.AddedDuration()
	case match.FieldMatchResult:
		return m.AddedMatchResult()
	case match.FieldMaxRounds:
		return m.AddedMaxRounds()
	}
	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 *MatchMutation) AddField(name string, value ent.Value) error {
	switch name {
	case match.FieldMatchID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddMatchID(v)
		return nil
	case match.FieldScoreTeamA:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddScoreTeamA(v)
		return nil
	case match.FieldScoreTeamB:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddScoreTeamB(v)
		return nil
	case match.FieldDuration:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDuration(v)
		return nil
	case match.FieldMatchResult:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddMatchResult(v)
		return nil
	case match.FieldMaxRounds:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddMaxRounds(v)
		return nil
	}
	return fmt.Errorf("unknown Match numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *MatchMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(match.FieldMap) {
		fields = append(fields, match.FieldMap)
	}
	if m.FieldCleared(match.FieldReplayURL) {
		fields = append(fields, match.FieldReplayURL)
	}
	if m.FieldCleared(match.FieldEco) {
		fields = append(fields, match.FieldEco)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MatchMutation) 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 *MatchMutation) ClearField(name string) error {
	switch name {
	case match.FieldMap:
		m.ClearMap()
		return nil
	case match.FieldReplayURL:
		m.ClearReplayURL()
		return nil
	case match.FieldEco:
		m.ClearEco()
		return nil
	}
	return fmt.Errorf("unknown Match 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 *MatchMutation) ResetField(name string) error {
	switch name {
	case match.FieldMatchID:
		m.ResetMatchID()
		return nil
	case match.FieldShareCode:
		m.ResetShareCode()
		return nil
	case match.FieldMap:
		m.ResetMap()
		return nil
	case match.FieldDate:
		m.ResetDate()
		return nil
	case match.FieldScoreTeamA:
		m.ResetScoreTeamA()
		return nil
	case match.FieldScoreTeamB:
		m.ResetScoreTeamB()
		return nil
	case match.FieldReplayURL:
		m.ResetReplayURL()
		return nil
	case match.FieldDuration:
		m.ResetDuration()
		return nil
	case match.FieldMatchResult:
		m.ResetMatchResult()
		return nil
	case match.FieldMaxRounds:
		m.ResetMaxRounds()
		return nil
	case match.FieldDemoExpired:
		m.ResetDemoExpired()
		return nil
	case match.FieldDemoParsed:
		m.ResetDemoParsed()
		return nil
	case match.FieldEco:
		m.ResetEco()
		return nil
	}
	return fmt.Errorf("unknown Match field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *MatchMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.stats != nil {
		edges = append(edges, match.EdgeStats)
	}
	if m.players != nil {
		edges = append(edges, match.EdgePlayers)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *MatchMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case match.EdgeStats:
		ids := make([]ent.Value, 0, len(m.stats))
		for id := range m.stats {
			ids = append(ids, id)
		}
		return ids
	case match.EdgePlayers:
		ids := make([]ent.Value, 0, len(m.players))
		for id := range m.players {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *MatchMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedstats != nil {
		edges = append(edges, match.EdgeStats)
	}
	if m.removedplayers != nil {
		edges = append(edges, match.EdgePlayers)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *MatchMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case match.EdgeStats:
		ids := make([]ent.Value, 0, len(m.removedstats))
		for id := range m.removedstats {
			ids = append(ids, id)
		}
		return ids
	case match.EdgePlayers:
		ids := make([]ent.Value, 0, len(m.removedplayers))
		for id := range m.removedplayers {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *MatchMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedstats {
		edges = append(edges, match.EdgeStats)
	}
	if m.clearedplayers {
		edges = append(edges, match.EdgePlayers)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *MatchMutation) EdgeCleared(name string) bool {
	switch name {
	case match.EdgeStats:
		return m.clearedstats
	case match.EdgePlayers:
		return m.clearedplayers
	}
	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 *MatchMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Match 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 *MatchMutation) ResetEdge(name string) error {
	switch name {
	case match.EdgeStats:
		m.ResetStats()
		return nil
	case match.EdgePlayers:
		m.ResetPlayers()
		return nil
	}
	return fmt.Errorf("unknown Match edge %s", name)
}

// PlayerMutation represents an operation that mutates the Player nodes in the graph.
type PlayerMutation struct {
	config
	op                Op
	typ               string
	id                *int
	steamid           *uint64
	addsteamid        *uint64
	name              *string
	avatar_url        *string
	vanity_url        *string
	vanity_url_real   *string
	vac               *bool
	vac_date          *time.Time
	vac_count         *int
	addvac_count      *int
	steam_updated     *time.Time
	sharecode_updated *time.Time
	auth_code         *string
	clearedFields     map[string]struct{}
	stats             map[int]struct{}
	removedstats      map[int]struct{}
	clearedstats      bool
	matches           map[int]struct{}
	removedmatches    map[int]struct{}
	clearedmatches    bool
	done              bool
	oldValue          func(context.Context) (*Player, error)
	predicates        []predicate.Player
}

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

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

// newPlayerMutation creates new mutation for the Player entity.
func newPlayerMutation(c config, op Op, opts ...playerOption) *PlayerMutation {
	m := &PlayerMutation{
		config:        c,
		op:            op,
		typ:           TypePlayer,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withPlayerID sets the ID field of the mutation.
func withPlayerID(id int) playerOption {
	return func(m *PlayerMutation) {
		var (
			err   error
			once  sync.Once
			value *Player
		)
		m.oldValue = func(ctx context.Context) (*Player, error) {
			once.Do(func() {
				if m.done {
					err = fmt.Errorf("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Player.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withPlayer sets the old Player of the mutation.
func withPlayer(node *Player) playerOption {
	return func(m *PlayerMutation) {
		m.oldValue = func(context.Context) (*Player, 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 PlayerMutation) 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 PlayerMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, fmt.Errorf("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 *PlayerMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// SetSteamid sets the "steamid" field.
func (m *PlayerMutation) SetSteamid(u uint64) {
	m.steamid = &u
	m.addsteamid = nil
}

// Steamid returns the value of the "steamid" field in the mutation.
func (m *PlayerMutation) Steamid() (r uint64, exists bool) {
	v := m.steamid
	if v == nil {
		return
	}
	return *v, true
}

// OldSteamid returns the old "steamid" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldSteamid(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldSteamid is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldSteamid requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSteamid: %w", err)
	}
	return oldValue.Steamid, nil
}

// AddSteamid adds u to the "steamid" field.
func (m *PlayerMutation) AddSteamid(u uint64) {
	if m.addsteamid != nil {
		*m.addsteamid += u
	} else {
		m.addsteamid = &u
	}
}

// AddedSteamid returns the value that was added to the "steamid" field in this mutation.
func (m *PlayerMutation) AddedSteamid() (r uint64, exists bool) {
	v := m.addsteamid
	if v == nil {
		return
	}
	return *v, true
}

// ResetSteamid resets all changes to the "steamid" field.
func (m *PlayerMutation) ResetSteamid() {
	m.steamid = nil
	m.addsteamid = nil
}

// SetName sets the "name" field.
func (m *PlayerMutation) SetName(s string) {
	m.name = &s
}

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

// OldName returns the old "name" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldName: %w", err)
	}
	return oldValue.Name, nil
}

// ClearName clears the value of the "name" field.
func (m *PlayerMutation) ClearName() {
	m.name = nil
	m.clearedFields[player.FieldName] = struct{}{}
}

// NameCleared returns if the "name" field was cleared in this mutation.
func (m *PlayerMutation) NameCleared() bool {
	_, ok := m.clearedFields[player.FieldName]
	return ok
}

// ResetName resets all changes to the "name" field.
func (m *PlayerMutation) ResetName() {
	m.name = nil
	delete(m.clearedFields, player.FieldName)
}

// SetAvatarURL sets the "avatar_url" field.
func (m *PlayerMutation) SetAvatarURL(s string) {
	m.avatar_url = &s
}

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

// OldAvatarURL returns the old "avatar_url" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldAvatarURL(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldAvatarURL is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldAvatarURL requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAvatarURL: %w", err)
	}
	return oldValue.AvatarURL, nil
}

// ClearAvatarURL clears the value of the "avatar_url" field.
func (m *PlayerMutation) ClearAvatarURL() {
	m.avatar_url = nil
	m.clearedFields[player.FieldAvatarURL] = struct{}{}
}

// AvatarURLCleared returns if the "avatar_url" field was cleared in this mutation.
func (m *PlayerMutation) AvatarURLCleared() bool {
	_, ok := m.clearedFields[player.FieldAvatarURL]
	return ok
}

// ResetAvatarURL resets all changes to the "avatar_url" field.
func (m *PlayerMutation) ResetAvatarURL() {
	m.avatar_url = nil
	delete(m.clearedFields, player.FieldAvatarURL)
}

// SetVanityURL sets the "vanity_url" field.
func (m *PlayerMutation) SetVanityURL(s string) {
	m.vanity_url = &s
}

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

// OldVanityURL returns the old "vanity_url" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldVanityURL(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldVanityURL is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldVanityURL requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVanityURL: %w", err)
	}
	return oldValue.VanityURL, nil
}

// ClearVanityURL clears the value of the "vanity_url" field.
func (m *PlayerMutation) ClearVanityURL() {
	m.vanity_url = nil
	m.clearedFields[player.FieldVanityURL] = struct{}{}
}

// VanityURLCleared returns if the "vanity_url" field was cleared in this mutation.
func (m *PlayerMutation) VanityURLCleared() bool {
	_, ok := m.clearedFields[player.FieldVanityURL]
	return ok
}

// ResetVanityURL resets all changes to the "vanity_url" field.
func (m *PlayerMutation) ResetVanityURL() {
	m.vanity_url = nil
	delete(m.clearedFields, player.FieldVanityURL)
}

// SetVanityURLReal sets the "vanity_url_real" field.
func (m *PlayerMutation) SetVanityURLReal(s string) {
	m.vanity_url_real = &s
}

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

// OldVanityURLReal returns the old "vanity_url_real" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldVanityURLReal(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldVanityURLReal is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldVanityURLReal requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVanityURLReal: %w", err)
	}
	return oldValue.VanityURLReal, nil
}

// ClearVanityURLReal clears the value of the "vanity_url_real" field.
func (m *PlayerMutation) ClearVanityURLReal() {
	m.vanity_url_real = nil
	m.clearedFields[player.FieldVanityURLReal] = struct{}{}
}

// VanityURLRealCleared returns if the "vanity_url_real" field was cleared in this mutation.
func (m *PlayerMutation) VanityURLRealCleared() bool {
	_, ok := m.clearedFields[player.FieldVanityURLReal]
	return ok
}

// ResetVanityURLReal resets all changes to the "vanity_url_real" field.
func (m *PlayerMutation) ResetVanityURLReal() {
	m.vanity_url_real = nil
	delete(m.clearedFields, player.FieldVanityURLReal)
}

// SetVac sets the "vac" field.
func (m *PlayerMutation) SetVac(b bool) {
	m.vac = &b
}

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

// OldVac returns the old "vac" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldVac(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldVac is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldVac requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVac: %w", err)
	}
	return oldValue.Vac, nil
}

// ResetVac resets all changes to the "vac" field.
func (m *PlayerMutation) ResetVac() {
	m.vac = nil
}

// SetVacDate sets the "vac_date" field.
func (m *PlayerMutation) SetVacDate(t time.Time) {
	m.vac_date = &t
}

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

// OldVacDate returns the old "vac_date" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldVacDate(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldVacDate is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldVacDate requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVacDate: %w", err)
	}
	return oldValue.VacDate, nil
}

// ClearVacDate clears the value of the "vac_date" field.
func (m *PlayerMutation) ClearVacDate() {
	m.vac_date = nil
	m.clearedFields[player.FieldVacDate] = struct{}{}
}

// VacDateCleared returns if the "vac_date" field was cleared in this mutation.
func (m *PlayerMutation) VacDateCleared() bool {
	_, ok := m.clearedFields[player.FieldVacDate]
	return ok
}

// ResetVacDate resets all changes to the "vac_date" field.
func (m *PlayerMutation) ResetVacDate() {
	m.vac_date = nil
	delete(m.clearedFields, player.FieldVacDate)
}

// SetVacCount sets the "vac_count" field.
func (m *PlayerMutation) SetVacCount(i int) {
	m.vac_count = &i
	m.addvac_count = nil
}

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

// OldVacCount returns the old "vac_count" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldVacCount(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldVacCount is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldVacCount requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVacCount: %w", err)
	}
	return oldValue.VacCount, nil
}

// AddVacCount adds i to the "vac_count" field.
func (m *PlayerMutation) AddVacCount(i int) {
	if m.addvac_count != nil {
		*m.addvac_count += i
	} else {
		m.addvac_count = &i
	}
}

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

// ClearVacCount clears the value of the "vac_count" field.
func (m *PlayerMutation) ClearVacCount() {
	m.vac_count = nil
	m.addvac_count = nil
	m.clearedFields[player.FieldVacCount] = struct{}{}
}

// VacCountCleared returns if the "vac_count" field was cleared in this mutation.
func (m *PlayerMutation) VacCountCleared() bool {
	_, ok := m.clearedFields[player.FieldVacCount]
	return ok
}

// ResetVacCount resets all changes to the "vac_count" field.
func (m *PlayerMutation) ResetVacCount() {
	m.vac_count = nil
	m.addvac_count = nil
	delete(m.clearedFields, player.FieldVacCount)
}

// SetSteamUpdated sets the "steam_updated" field.
func (m *PlayerMutation) SetSteamUpdated(t time.Time) {
	m.steam_updated = &t
}

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

// OldSteamUpdated returns the old "steam_updated" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldSteamUpdated(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldSteamUpdated is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldSteamUpdated requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSteamUpdated: %w", err)
	}
	return oldValue.SteamUpdated, nil
}

// ResetSteamUpdated resets all changes to the "steam_updated" field.
func (m *PlayerMutation) ResetSteamUpdated() {
	m.steam_updated = nil
}

// SetSharecodeUpdated sets the "sharecode_updated" field.
func (m *PlayerMutation) SetSharecodeUpdated(t time.Time) {
	m.sharecode_updated = &t
}

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

// OldSharecodeUpdated returns the old "sharecode_updated" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldSharecodeUpdated(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldSharecodeUpdated is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldSharecodeUpdated requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSharecodeUpdated: %w", err)
	}
	return oldValue.SharecodeUpdated, nil
}

// ClearSharecodeUpdated clears the value of the "sharecode_updated" field.
func (m *PlayerMutation) ClearSharecodeUpdated() {
	m.sharecode_updated = nil
	m.clearedFields[player.FieldSharecodeUpdated] = struct{}{}
}

// SharecodeUpdatedCleared returns if the "sharecode_updated" field was cleared in this mutation.
func (m *PlayerMutation) SharecodeUpdatedCleared() bool {
	_, ok := m.clearedFields[player.FieldSharecodeUpdated]
	return ok
}

// ResetSharecodeUpdated resets all changes to the "sharecode_updated" field.
func (m *PlayerMutation) ResetSharecodeUpdated() {
	m.sharecode_updated = nil
	delete(m.clearedFields, player.FieldSharecodeUpdated)
}

// SetAuthCode sets the "auth_code" field.
func (m *PlayerMutation) SetAuthCode(s string) {
	m.auth_code = &s
}

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

// OldAuthCode returns the old "auth_code" field's value of the Player entity.
// If the Player 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 *PlayerMutation) OldAuthCode(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldAuthCode is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldAuthCode requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAuthCode: %w", err)
	}
	return oldValue.AuthCode, nil
}

// ClearAuthCode clears the value of the "auth_code" field.
func (m *PlayerMutation) ClearAuthCode() {
	m.auth_code = nil
	m.clearedFields[player.FieldAuthCode] = struct{}{}
}

// AuthCodeCleared returns if the "auth_code" field was cleared in this mutation.
func (m *PlayerMutation) AuthCodeCleared() bool {
	_, ok := m.clearedFields[player.FieldAuthCode]
	return ok
}

// ResetAuthCode resets all changes to the "auth_code" field.
func (m *PlayerMutation) ResetAuthCode() {
	m.auth_code = nil
	delete(m.clearedFields, player.FieldAuthCode)
}

// AddStatIDs adds the "stats" edge to the Stats entity by ids.
func (m *PlayerMutation) AddStatIDs(ids ...int) {
	if m.stats == nil {
		m.stats = make(map[int]struct{})
	}
	for i := range ids {
		m.stats[ids[i]] = struct{}{}
	}
}

// ClearStats clears the "stats" edge to the Stats entity.
func (m *PlayerMutation) ClearStats() {
	m.clearedstats = true
}

// StatsCleared reports if the "stats" edge to the Stats entity was cleared.
func (m *PlayerMutation) StatsCleared() bool {
	return m.clearedstats
}

// RemoveStatIDs removes the "stats" edge to the Stats entity by IDs.
func (m *PlayerMutation) RemoveStatIDs(ids ...int) {
	if m.removedstats == nil {
		m.removedstats = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.stats, ids[i])
		m.removedstats[ids[i]] = struct{}{}
	}
}

// RemovedStats returns the removed IDs of the "stats" edge to the Stats entity.
func (m *PlayerMutation) RemovedStatsIDs() (ids []int) {
	for id := range m.removedstats {
		ids = append(ids, id)
	}
	return
}

// StatsIDs returns the "stats" edge IDs in the mutation.
func (m *PlayerMutation) StatsIDs() (ids []int) {
	for id := range m.stats {
		ids = append(ids, id)
	}
	return
}

// ResetStats resets all changes to the "stats" edge.
func (m *PlayerMutation) ResetStats() {
	m.stats = nil
	m.clearedstats = false
	m.removedstats = nil
}

// AddMatchIDs adds the "matches" edge to the Match entity by ids.
func (m *PlayerMutation) AddMatchIDs(ids ...int) {
	if m.matches == nil {
		m.matches = make(map[int]struct{})
	}
	for i := range ids {
		m.matches[ids[i]] = struct{}{}
	}
}

// ClearMatches clears the "matches" edge to the Match entity.
func (m *PlayerMutation) ClearMatches() {
	m.clearedmatches = true
}

// MatchesCleared reports if the "matches" edge to the Match entity was cleared.
func (m *PlayerMutation) MatchesCleared() bool {
	return m.clearedmatches
}

// RemoveMatchIDs removes the "matches" edge to the Match entity by IDs.
func (m *PlayerMutation) RemoveMatchIDs(ids ...int) {
	if m.removedmatches == nil {
		m.removedmatches = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.matches, ids[i])
		m.removedmatches[ids[i]] = struct{}{}
	}
}

// RemovedMatches returns the removed IDs of the "matches" edge to the Match entity.
func (m *PlayerMutation) RemovedMatchesIDs() (ids []int) {
	for id := range m.removedmatches {
		ids = append(ids, id)
	}
	return
}

// MatchesIDs returns the "matches" edge IDs in the mutation.
func (m *PlayerMutation) MatchesIDs() (ids []int) {
	for id := range m.matches {
		ids = append(ids, id)
	}
	return
}

// ResetMatches resets all changes to the "matches" edge.
func (m *PlayerMutation) ResetMatches() {
	m.matches = nil
	m.clearedmatches = false
	m.removedmatches = nil
}

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

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

// Type returns the node type of this mutation (Player).
func (m *PlayerMutation) 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 *PlayerMutation) Fields() []string {
	fields := make([]string, 0, 11)
	if m.steamid != nil {
		fields = append(fields, player.FieldSteamid)
	}
	if m.name != nil {
		fields = append(fields, player.FieldName)
	}
	if m.avatar_url != nil {
		fields = append(fields, player.FieldAvatarURL)
	}
	if m.vanity_url != nil {
		fields = append(fields, player.FieldVanityURL)
	}
	if m.vanity_url_real != nil {
		fields = append(fields, player.FieldVanityURLReal)
	}
	if m.vac != nil {
		fields = append(fields, player.FieldVac)
	}
	if m.vac_date != nil {
		fields = append(fields, player.FieldVacDate)
	}
	if m.vac_count != nil {
		fields = append(fields, player.FieldVacCount)
	}
	if m.steam_updated != nil {
		fields = append(fields, player.FieldSteamUpdated)
	}
	if m.sharecode_updated != nil {
		fields = append(fields, player.FieldSharecodeUpdated)
	}
	if m.auth_code != nil {
		fields = append(fields, player.FieldAuthCode)
	}
	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 *PlayerMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case player.FieldSteamid:
		return m.Steamid()
	case player.FieldName:
		return m.Name()
	case player.FieldAvatarURL:
		return m.AvatarURL()
	case player.FieldVanityURL:
		return m.VanityURL()
	case player.FieldVanityURLReal:
		return m.VanityURLReal()
	case player.FieldVac:
		return m.Vac()
	case player.FieldVacDate:
		return m.VacDate()
	case player.FieldVacCount:
		return m.VacCount()
	case player.FieldSteamUpdated:
		return m.SteamUpdated()
	case player.FieldSharecodeUpdated:
		return m.SharecodeUpdated()
	case player.FieldAuthCode:
		return m.AuthCode()
	}
	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 *PlayerMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case player.FieldSteamid:
		return m.OldSteamid(ctx)
	case player.FieldName:
		return m.OldName(ctx)
	case player.FieldAvatarURL:
		return m.OldAvatarURL(ctx)
	case player.FieldVanityURL:
		return m.OldVanityURL(ctx)
	case player.FieldVanityURLReal:
		return m.OldVanityURLReal(ctx)
	case player.FieldVac:
		return m.OldVac(ctx)
	case player.FieldVacDate:
		return m.OldVacDate(ctx)
	case player.FieldVacCount:
		return m.OldVacCount(ctx)
	case player.FieldSteamUpdated:
		return m.OldSteamUpdated(ctx)
	case player.FieldSharecodeUpdated:
		return m.OldSharecodeUpdated(ctx)
	case player.FieldAuthCode:
		return m.OldAuthCode(ctx)
	}
	return nil, fmt.Errorf("unknown Player 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 *PlayerMutation) SetField(name string, value ent.Value) error {
	switch name {
	case player.FieldSteamid:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSteamid(v)
		return nil
	case player.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case player.FieldAvatarURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatarURL(v)
		return nil
	case player.FieldVanityURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVanityURL(v)
		return nil
	case player.FieldVanityURLReal:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVanityURLReal(v)
		return nil
	case player.FieldVac:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVac(v)
		return nil
	case player.FieldVacDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVacDate(v)
		return nil
	case player.FieldVacCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVacCount(v)
		return nil
	case player.FieldSteamUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSteamUpdated(v)
		return nil
	case player.FieldSharecodeUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSharecodeUpdated(v)
		return nil
	case player.FieldAuthCode:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAuthCode(v)
		return nil
	}
	return fmt.Errorf("unknown Player field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *PlayerMutation) AddedFields() []string {
	var fields []string
	if m.addsteamid != nil {
		fields = append(fields, player.FieldSteamid)
	}
	if m.addvac_count != nil {
		fields = append(fields, player.FieldVacCount)
	}
	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 *PlayerMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case player.FieldSteamid:
		return m.AddedSteamid()
	case player.FieldVacCount:
		return m.AddedVacCount()
	}
	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 *PlayerMutation) AddField(name string, value ent.Value) error {
	switch name {
	case player.FieldSteamid:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSteamid(v)
		return nil
	case player.FieldVacCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddVacCount(v)
		return nil
	}
	return fmt.Errorf("unknown Player numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *PlayerMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(player.FieldName) {
		fields = append(fields, player.FieldName)
	}
	if m.FieldCleared(player.FieldAvatarURL) {
		fields = append(fields, player.FieldAvatarURL)
	}
	if m.FieldCleared(player.FieldVanityURL) {
		fields = append(fields, player.FieldVanityURL)
	}
	if m.FieldCleared(player.FieldVanityURLReal) {
		fields = append(fields, player.FieldVanityURLReal)
	}
	if m.FieldCleared(player.FieldVacDate) {
		fields = append(fields, player.FieldVacDate)
	}
	if m.FieldCleared(player.FieldVacCount) {
		fields = append(fields, player.FieldVacCount)
	}
	if m.FieldCleared(player.FieldSharecodeUpdated) {
		fields = append(fields, player.FieldSharecodeUpdated)
	}
	if m.FieldCleared(player.FieldAuthCode) {
		fields = append(fields, player.FieldAuthCode)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PlayerMutation) 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 *PlayerMutation) ClearField(name string) error {
	switch name {
	case player.FieldName:
		m.ClearName()
		return nil
	case player.FieldAvatarURL:
		m.ClearAvatarURL()
		return nil
	case player.FieldVanityURL:
		m.ClearVanityURL()
		return nil
	case player.FieldVanityURLReal:
		m.ClearVanityURLReal()
		return nil
	case player.FieldVacDate:
		m.ClearVacDate()
		return nil
	case player.FieldVacCount:
		m.ClearVacCount()
		return nil
	case player.FieldSharecodeUpdated:
		m.ClearSharecodeUpdated()
		return nil
	case player.FieldAuthCode:
		m.ClearAuthCode()
		return nil
	}
	return fmt.Errorf("unknown Player 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 *PlayerMutation) ResetField(name string) error {
	switch name {
	case player.FieldSteamid:
		m.ResetSteamid()
		return nil
	case player.FieldName:
		m.ResetName()
		return nil
	case player.FieldAvatarURL:
		m.ResetAvatarURL()
		return nil
	case player.FieldVanityURL:
		m.ResetVanityURL()
		return nil
	case player.FieldVanityURLReal:
		m.ResetVanityURLReal()
		return nil
	case player.FieldVac:
		m.ResetVac()
		return nil
	case player.FieldVacDate:
		m.ResetVacDate()
		return nil
	case player.FieldVacCount:
		m.ResetVacCount()
		return nil
	case player.FieldSteamUpdated:
		m.ResetSteamUpdated()
		return nil
	case player.FieldSharecodeUpdated:
		m.ResetSharecodeUpdated()
		return nil
	case player.FieldAuthCode:
		m.ResetAuthCode()
		return nil
	}
	return fmt.Errorf("unknown Player field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *PlayerMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.stats != nil {
		edges = append(edges, player.EdgeStats)
	}
	if m.matches != nil {
		edges = append(edges, player.EdgeMatches)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *PlayerMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case player.EdgeStats:
		ids := make([]ent.Value, 0, len(m.stats))
		for id := range m.stats {
			ids = append(ids, id)
		}
		return ids
	case player.EdgeMatches:
		ids := make([]ent.Value, 0, len(m.matches))
		for id := range m.matches {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *PlayerMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedstats != nil {
		edges = append(edges, player.EdgeStats)
	}
	if m.removedmatches != nil {
		edges = append(edges, player.EdgeMatches)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *PlayerMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case player.EdgeStats:
		ids := make([]ent.Value, 0, len(m.removedstats))
		for id := range m.removedstats {
			ids = append(ids, id)
		}
		return ids
	case player.EdgeMatches:
		ids := make([]ent.Value, 0, len(m.removedmatches))
		for id := range m.removedmatches {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PlayerMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedstats {
		edges = append(edges, player.EdgeStats)
	}
	if m.clearedmatches {
		edges = append(edges, player.EdgeMatches)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *PlayerMutation) EdgeCleared(name string) bool {
	switch name {
	case player.EdgeStats:
		return m.clearedstats
	case player.EdgeMatches:
		return m.clearedmatches
	}
	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 *PlayerMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Player 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 *PlayerMutation) ResetEdge(name string) error {
	switch name {
	case player.EdgeStats:
		m.ResetStats()
		return nil
	case player.EdgeMatches:
		m.ResetMatches()
		return nil
	}
	return fmt.Errorf("unknown Player edge %s", name)
}

// StatsMutation represents an operation that mutates the Stats nodes in the graph.
type StatsMutation struct {
	config
	op          Op
	typ         string
	id          *int
	team_id     *int
	addteam_id  *int
	kills       *int
	addkills    *int
	deaths      *int
	adddeaths   *int
	assists     *int
	addassists  *int
	headshot    *int
	addheadshot *int
	mvp         *int
	addmvp      *int
	score       *int
	addscore    *int
	extended    *struct {
		MultiKills struct {
			Duo    int "json:\"duo,omitempty\""
			Triple int "json:\"triple,omitempty\""
			Quad   int "json:\"quad,omitempty\""
			Pent   int "json:\"pent,omitempty\""
		} "json:\"multi_kills,omitempty\""
		Dmg struct {
			Enemy int "json:\"enemy,omitempty\""
			Team  int "json:\"team,omitempty\""
			UD    struct {
				HE     int "json:\"he,omitempty\""
				Flames int "json:\"flames,omitempty\""
				Flash  int "json:\"flash,omitempty\""
				Decoy  int "json:\"decoy,omitempty\""
				Smoke  int "json:\"smoke,omitempty\""
			} "json:\"ud,omitempty\""
			HitGroup struct {
				Head     int "json:\"head,omitempty\""
				Chest    int "json:\"chest,omitempty\""
				Stomach  int "json:\"stomach,omitempty\""
				LeftArm  int "json:\"left_arm,omitempty\""
				RightArm int "json:\"right_arm,omitempty\""
				LeftLeg  int "json:\"left_leg,omitempty\""
				RightLeg int "json:\"right_leg,omitempty\""
				Gear     int "json:\"gear,omitempty\""
			} "json:\"hit_group,omitempty\""
		} "json:\"dmg,omitempty\""
		Crosshair string "json:\"crosshair,omitempty\""
		Color     int    "json:\"color,omitempty\""
		KAST      int    "json:\"kast,omitempty\""
		Rank      struct {
			Old int "json:\"old,omitempty\""
			New int "json:\"new,omitempty\""
		} "json:\"rank,omitempty\""
		Flash struct {
			Duration struct {
				Self  float32 "json:\"self,omitempty\""
				Team  float32 "json:\"team,omitempty\""
				Enemy float32 "json:\"enemy,omitempty\""
			} "json:\"duration,omitempty\""
			Total struct {
				Team  int "json:\"team,omitempty\""
				Enemy int "json:\"enemy,omitempty\""
				Self  int "json:\"self,omitempty\""
			} "json:\"total,omitempty\""
		} "json:\"flash,omitempty\""
	}
	clearedFields  map[string]struct{}
	matches        *int
	clearedmatches bool
	players        *int
	clearedplayers bool
	done           bool
	oldValue       func(context.Context) (*Stats, error)
	predicates     []predicate.Stats
}

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

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

// newStatsMutation creates new mutation for the Stats entity.
func newStatsMutation(c config, op Op, opts ...statsOption) *StatsMutation {
	m := &StatsMutation{
		config:        c,
		op:            op,
		typ:           TypeStats,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withStatsID sets the ID field of the mutation.
func withStatsID(id int) statsOption {
	return func(m *StatsMutation) {
		var (
			err   error
			once  sync.Once
			value *Stats
		)
		m.oldValue = func(ctx context.Context) (*Stats, error) {
			once.Do(func() {
				if m.done {
					err = fmt.Errorf("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Stats.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withStats sets the old Stats of the mutation.
func withStats(node *Stats) statsOption {
	return func(m *StatsMutation) {
		m.oldValue = func(context.Context) (*Stats, 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 StatsMutation) 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 StatsMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, fmt.Errorf("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 *StatsMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// SetTeamID sets the "team_id" field.
func (m *StatsMutation) SetTeamID(i int) {
	m.team_id = &i
	m.addteam_id = nil
}

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

// OldTeamID returns the old "team_id" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldTeamID(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldTeamID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldTeamID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTeamID: %w", err)
	}
	return oldValue.TeamID, nil
}

// AddTeamID adds i to the "team_id" field.
func (m *StatsMutation) AddTeamID(i int) {
	if m.addteam_id != nil {
		*m.addteam_id += i
	} else {
		m.addteam_id = &i
	}
}

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

// ResetTeamID resets all changes to the "team_id" field.
func (m *StatsMutation) ResetTeamID() {
	m.team_id = nil
	m.addteam_id = nil
}

// SetKills sets the "kills" field.
func (m *StatsMutation) SetKills(i int) {
	m.kills = &i
	m.addkills = nil
}

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

// OldKills returns the old "kills" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldKills(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldKills is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldKills requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldKills: %w", err)
	}
	return oldValue.Kills, nil
}

// AddKills adds i to the "kills" field.
func (m *StatsMutation) AddKills(i int) {
	if m.addkills != nil {
		*m.addkills += i
	} else {
		m.addkills = &i
	}
}

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

// ResetKills resets all changes to the "kills" field.
func (m *StatsMutation) ResetKills() {
	m.kills = nil
	m.addkills = nil
}

// SetDeaths sets the "deaths" field.
func (m *StatsMutation) SetDeaths(i int) {
	m.deaths = &i
	m.adddeaths = nil
}

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

// OldDeaths returns the old "deaths" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldDeaths(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldDeaths is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldDeaths requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDeaths: %w", err)
	}
	return oldValue.Deaths, nil
}

// AddDeaths adds i to the "deaths" field.
func (m *StatsMutation) AddDeaths(i int) {
	if m.adddeaths != nil {
		*m.adddeaths += i
	} else {
		m.adddeaths = &i
	}
}

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

// ResetDeaths resets all changes to the "deaths" field.
func (m *StatsMutation) ResetDeaths() {
	m.deaths = nil
	m.adddeaths = nil
}

// SetAssists sets the "assists" field.
func (m *StatsMutation) SetAssists(i int) {
	m.assists = &i
	m.addassists = nil
}

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

// OldAssists returns the old "assists" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldAssists(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldAssists is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldAssists requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAssists: %w", err)
	}
	return oldValue.Assists, nil
}

// AddAssists adds i to the "assists" field.
func (m *StatsMutation) AddAssists(i int) {
	if m.addassists != nil {
		*m.addassists += i
	} else {
		m.addassists = &i
	}
}

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

// ResetAssists resets all changes to the "assists" field.
func (m *StatsMutation) ResetAssists() {
	m.assists = nil
	m.addassists = nil
}

// SetHeadshot sets the "headshot" field.
func (m *StatsMutation) SetHeadshot(i int) {
	m.headshot = &i
	m.addheadshot = nil
}

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

// OldHeadshot returns the old "headshot" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldHeadshot(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldHeadshot is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldHeadshot requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldHeadshot: %w", err)
	}
	return oldValue.Headshot, nil
}

// AddHeadshot adds i to the "headshot" field.
func (m *StatsMutation) AddHeadshot(i int) {
	if m.addheadshot != nil {
		*m.addheadshot += i
	} else {
		m.addheadshot = &i
	}
}

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

// ResetHeadshot resets all changes to the "headshot" field.
func (m *StatsMutation) ResetHeadshot() {
	m.headshot = nil
	m.addheadshot = nil
}

// SetMvp sets the "mvp" field.
func (m *StatsMutation) SetMvp(i int) {
	m.mvp = &i
	m.addmvp = nil
}

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

// OldMvp returns the old "mvp" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldMvp(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldMvp is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldMvp requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMvp: %w", err)
	}
	return oldValue.Mvp, nil
}

// AddMvp adds i to the "mvp" field.
func (m *StatsMutation) AddMvp(i int) {
	if m.addmvp != nil {
		*m.addmvp += i
	} else {
		m.addmvp = &i
	}
}

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

// ResetMvp resets all changes to the "mvp" field.
func (m *StatsMutation) ResetMvp() {
	m.mvp = nil
	m.addmvp = nil
}

// SetScore sets the "score" field.
func (m *StatsMutation) SetScore(i int) {
	m.score = &i
	m.addscore = nil
}

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

// OldScore returns the old "score" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldScore(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldScore is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldScore requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldScore: %w", err)
	}
	return oldValue.Score, nil
}

// AddScore adds i to the "score" field.
func (m *StatsMutation) AddScore(i int) {
	if m.addscore != nil {
		*m.addscore += i
	} else {
		m.addscore = &i
	}
}

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

// ResetScore resets all changes to the "score" field.
func (m *StatsMutation) ResetScore() {
	m.score = nil
	m.addscore = nil
}

// SetExtended sets the "extended" field.
func (m *StatsMutation) SetExtended(skkgaaaallllg struct {
	MultiKills struct {
		Duo    int "json:\"duo,omitempty\""
		Triple int "json:\"triple,omitempty\""
		Quad   int "json:\"quad,omitempty\""
		Pent   int "json:\"pent,omitempty\""
	} "json:\"multi_kills,omitempty\""
	Dmg struct {
		Enemy int "json:\"enemy,omitempty\""
		Team  int "json:\"team,omitempty\""
		UD    struct {
			HE     int "json:\"he,omitempty\""
			Flames int "json:\"flames,omitempty\""
			Flash  int "json:\"flash,omitempty\""
			Decoy  int "json:\"decoy,omitempty\""
			Smoke  int "json:\"smoke,omitempty\""
		} "json:\"ud,omitempty\""
		HitGroup struct {
			Head     int "json:\"head,omitempty\""
			Chest    int "json:\"chest,omitempty\""
			Stomach  int "json:\"stomach,omitempty\""
			LeftArm  int "json:\"left_arm,omitempty\""
			RightArm int "json:\"right_arm,omitempty\""
			LeftLeg  int "json:\"left_leg,omitempty\""
			RightLeg int "json:\"right_leg,omitempty\""
			Gear     int "json:\"gear,omitempty\""
		} "json:\"hit_group,omitempty\""
	} "json:\"dmg,omitempty\""
	Crosshair string "json:\"crosshair,omitempty\""
	Color     int    "json:\"color,omitempty\""
	KAST      int    "json:\"kast,omitempty\""
	Rank      struct {
		Old int "json:\"old,omitempty\""
		New int "json:\"new,omitempty\""
	} "json:\"rank,omitempty\""
	Flash struct {
		Duration struct {
			Self  float32 "json:\"self,omitempty\""
			Team  float32 "json:\"team,omitempty\""
			Enemy float32 "json:\"enemy,omitempty\""
		} "json:\"duration,omitempty\""
		Total struct {
			Team  int "json:\"team,omitempty\""
			Enemy int "json:\"enemy,omitempty\""
			Self  int "json:\"self,omitempty\""
		} "json:\"total,omitempty\""
	} "json:\"flash,omitempty\""
}) {
	m.extended = &skkgaaaallllg
}

// Extended returns the value of the "extended" field in the mutation.
func (m *StatsMutation) Extended() (r struct {
	MultiKills struct {
		Duo    int "json:\"duo,omitempty\""
		Triple int "json:\"triple,omitempty\""
		Quad   int "json:\"quad,omitempty\""
		Pent   int "json:\"pent,omitempty\""
	} "json:\"multi_kills,omitempty\""
	Dmg struct {
		Enemy int "json:\"enemy,omitempty\""
		Team  int "json:\"team,omitempty\""
		UD    struct {
			HE     int "json:\"he,omitempty\""
			Flames int "json:\"flames,omitempty\""
			Flash  int "json:\"flash,omitempty\""
			Decoy  int "json:\"decoy,omitempty\""
			Smoke  int "json:\"smoke,omitempty\""
		} "json:\"ud,omitempty\""
		HitGroup struct {
			Head     int "json:\"head,omitempty\""
			Chest    int "json:\"chest,omitempty\""
			Stomach  int "json:\"stomach,omitempty\""
			LeftArm  int "json:\"left_arm,omitempty\""
			RightArm int "json:\"right_arm,omitempty\""
			LeftLeg  int "json:\"left_leg,omitempty\""
			RightLeg int "json:\"right_leg,omitempty\""
			Gear     int "json:\"gear,omitempty\""
		} "json:\"hit_group,omitempty\""
	} "json:\"dmg,omitempty\""
	Crosshair string "json:\"crosshair,omitempty\""
	Color     int    "json:\"color,omitempty\""
	KAST      int    "json:\"kast,omitempty\""
	Rank      struct {
		Old int "json:\"old,omitempty\""
		New int "json:\"new,omitempty\""
	} "json:\"rank,omitempty\""
	Flash struct {
		Duration struct {
			Self  float32 "json:\"self,omitempty\""
			Team  float32 "json:\"team,omitempty\""
			Enemy float32 "json:\"enemy,omitempty\""
		} "json:\"duration,omitempty\""
		Total struct {
			Team  int "json:\"team,omitempty\""
			Enemy int "json:\"enemy,omitempty\""
			Self  int "json:\"self,omitempty\""
		} "json:\"total,omitempty\""
	} "json:\"flash,omitempty\""
}, exists bool) {
	v := m.extended
	if v == nil {
		return
	}
	return *v, true
}

// OldExtended returns the old "extended" field's value of the Stats entity.
// If the Stats 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 *StatsMutation) OldExtended(ctx context.Context) (v struct {
	MultiKills struct {
		Duo    int "json:\"duo,omitempty\""
		Triple int "json:\"triple,omitempty\""
		Quad   int "json:\"quad,omitempty\""
		Pent   int "json:\"pent,omitempty\""
	} "json:\"multi_kills,omitempty\""
	Dmg struct {
		Enemy int "json:\"enemy,omitempty\""
		Team  int "json:\"team,omitempty\""
		UD    struct {
			HE     int "json:\"he,omitempty\""
			Flames int "json:\"flames,omitempty\""
			Flash  int "json:\"flash,omitempty\""
			Decoy  int "json:\"decoy,omitempty\""
			Smoke  int "json:\"smoke,omitempty\""
		} "json:\"ud,omitempty\""
		HitGroup struct {
			Head     int "json:\"head,omitempty\""
			Chest    int "json:\"chest,omitempty\""
			Stomach  int "json:\"stomach,omitempty\""
			LeftArm  int "json:\"left_arm,omitempty\""
			RightArm int "json:\"right_arm,omitempty\""
			LeftLeg  int "json:\"left_leg,omitempty\""
			RightLeg int "json:\"right_leg,omitempty\""
			Gear     int "json:\"gear,omitempty\""
		} "json:\"hit_group,omitempty\""
	} "json:\"dmg,omitempty\""
	Crosshair string "json:\"crosshair,omitempty\""
	Color     int    "json:\"color,omitempty\""
	KAST      int    "json:\"kast,omitempty\""
	Rank      struct {
		Old int "json:\"old,omitempty\""
		New int "json:\"new,omitempty\""
	} "json:\"rank,omitempty\""
	Flash struct {
		Duration struct {
			Self  float32 "json:\"self,omitempty\""
			Team  float32 "json:\"team,omitempty\""
			Enemy float32 "json:\"enemy,omitempty\""
		} "json:\"duration,omitempty\""
		Total struct {
			Team  int "json:\"team,omitempty\""
			Enemy int "json:\"enemy,omitempty\""
			Self  int "json:\"self,omitempty\""
		} "json:\"total,omitempty\""
	} "json:\"flash,omitempty\""
}, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldExtended is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldExtended requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldExtended: %w", err)
	}
	return oldValue.Extended, nil
}

// ClearExtended clears the value of the "extended" field.
func (m *StatsMutation) ClearExtended() {
	m.extended = nil
	m.clearedFields[stats.FieldExtended] = struct{}{}
}

// ExtendedCleared returns if the "extended" field was cleared in this mutation.
func (m *StatsMutation) ExtendedCleared() bool {
	_, ok := m.clearedFields[stats.FieldExtended]
	return ok
}

// ResetExtended resets all changes to the "extended" field.
func (m *StatsMutation) ResetExtended() {
	m.extended = nil
	delete(m.clearedFields, stats.FieldExtended)
}

// SetMatchesID sets the "matches" edge to the Match entity by id.
func (m *StatsMutation) SetMatchesID(id int) {
	m.matches = &id
}

// ClearMatches clears the "matches" edge to the Match entity.
func (m *StatsMutation) ClearMatches() {
	m.clearedmatches = true
}

// MatchesCleared reports if the "matches" edge to the Match entity was cleared.
func (m *StatsMutation) MatchesCleared() bool {
	return m.clearedmatches
}

// MatchesID returns the "matches" edge ID in the mutation.
func (m *StatsMutation) MatchesID() (id int, exists bool) {
	if m.matches != nil {
		return *m.matches, true
	}
	return
}

// MatchesIDs returns the "matches" edge IDs in the mutation.
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
// MatchesID instead. It exists only for internal usage by the builders.
func (m *StatsMutation) MatchesIDs() (ids []int) {
	if id := m.matches; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetMatches resets all changes to the "matches" edge.
func (m *StatsMutation) ResetMatches() {
	m.matches = nil
	m.clearedmatches = false
}

// SetPlayersID sets the "players" edge to the Player entity by id.
func (m *StatsMutation) SetPlayersID(id int) {
	m.players = &id
}

// ClearPlayers clears the "players" edge to the Player entity.
func (m *StatsMutation) ClearPlayers() {
	m.clearedplayers = true
}

// PlayersCleared reports if the "players" edge to the Player entity was cleared.
func (m *StatsMutation) PlayersCleared() bool {
	return m.clearedplayers
}

// PlayersID returns the "players" edge ID in the mutation.
func (m *StatsMutation) PlayersID() (id int, exists bool) {
	if m.players != nil {
		return *m.players, true
	}
	return
}

// PlayersIDs returns the "players" edge IDs in the mutation.
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
// PlayersID instead. It exists only for internal usage by the builders.
func (m *StatsMutation) PlayersIDs() (ids []int) {
	if id := m.players; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetPlayers resets all changes to the "players" edge.
func (m *StatsMutation) ResetPlayers() {
	m.players = nil
	m.clearedplayers = false
}

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

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

// Type returns the node type of this mutation (Stats).
func (m *StatsMutation) 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 *StatsMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.team_id != nil {
		fields = append(fields, stats.FieldTeamID)
	}
	if m.kills != nil {
		fields = append(fields, stats.FieldKills)
	}
	if m.deaths != nil {
		fields = append(fields, stats.FieldDeaths)
	}
	if m.assists != nil {
		fields = append(fields, stats.FieldAssists)
	}
	if m.headshot != nil {
		fields = append(fields, stats.FieldHeadshot)
	}
	if m.mvp != nil {
		fields = append(fields, stats.FieldMvp)
	}
	if m.score != nil {
		fields = append(fields, stats.FieldScore)
	}
	if m.extended != nil {
		fields = append(fields, stats.FieldExtended)
	}
	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 *StatsMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case stats.FieldTeamID:
		return m.TeamID()
	case stats.FieldKills:
		return m.Kills()
	case stats.FieldDeaths:
		return m.Deaths()
	case stats.FieldAssists:
		return m.Assists()
	case stats.FieldHeadshot:
		return m.Headshot()
	case stats.FieldMvp:
		return m.Mvp()
	case stats.FieldScore:
		return m.Score()
	case stats.FieldExtended:
		return m.Extended()
	}
	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 *StatsMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case stats.FieldTeamID:
		return m.OldTeamID(ctx)
	case stats.FieldKills:
		return m.OldKills(ctx)
	case stats.FieldDeaths:
		return m.OldDeaths(ctx)
	case stats.FieldAssists:
		return m.OldAssists(ctx)
	case stats.FieldHeadshot:
		return m.OldHeadshot(ctx)
	case stats.FieldMvp:
		return m.OldMvp(ctx)
	case stats.FieldScore:
		return m.OldScore(ctx)
	case stats.FieldExtended:
		return m.OldExtended(ctx)
	}
	return nil, fmt.Errorf("unknown Stats 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 *StatsMutation) SetField(name string, value ent.Value) error {
	switch name {
	case stats.FieldTeamID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTeamID(v)
		return nil
	case stats.FieldKills:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetKills(v)
		return nil
	case stats.FieldDeaths:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeaths(v)
		return nil
	case stats.FieldAssists:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAssists(v)
		return nil
	case stats.FieldHeadshot:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHeadshot(v)
		return nil
	case stats.FieldMvp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMvp(v)
		return nil
	case stats.FieldScore:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetScore(v)
		return nil
	case stats.FieldExtended:
		v, ok := value.(struct {
			MultiKills struct {
				Duo    int "json:\"duo,omitempty\""
				Triple int "json:\"triple,omitempty\""
				Quad   int "json:\"quad,omitempty\""
				Pent   int "json:\"pent,omitempty\""
			} "json:\"multi_kills,omitempty\""
			Dmg struct {
				Enemy int "json:\"enemy,omitempty\""
				Team  int "json:\"team,omitempty\""
				UD    struct {
					HE     int "json:\"he,omitempty\""
					Flames int "json:\"flames,omitempty\""
					Flash  int "json:\"flash,omitempty\""
					Decoy  int "json:\"decoy,omitempty\""
					Smoke  int "json:\"smoke,omitempty\""
				} "json:\"ud,omitempty\""
				HitGroup struct {
					Head     int "json:\"head,omitempty\""
					Chest    int "json:\"chest,omitempty\""
					Stomach  int "json:\"stomach,omitempty\""
					LeftArm  int "json:\"left_arm,omitempty\""
					RightArm int "json:\"right_arm,omitempty\""
					LeftLeg  int "json:\"left_leg,omitempty\""
					RightLeg int "json:\"right_leg,omitempty\""
					Gear     int "json:\"gear,omitempty\""
				} "json:\"hit_group,omitempty\""
			} "json:\"dmg,omitempty\""
			Crosshair string "json:\"crosshair,omitempty\""
			Color     int    "json:\"color,omitempty\""
			KAST      int    "json:\"kast,omitempty\""
			Rank      struct {
				Old int "json:\"old,omitempty\""
				New int "json:\"new,omitempty\""
			} "json:\"rank,omitempty\""
			Flash struct {
				Duration struct {
					Self  float32 "json:\"self,omitempty\""
					Team  float32 "json:\"team,omitempty\""
					Enemy float32 "json:\"enemy,omitempty\""
				} "json:\"duration,omitempty\""
				Total struct {
					Team  int "json:\"team,omitempty\""
					Enemy int "json:\"enemy,omitempty\""
					Self  int "json:\"self,omitempty\""
				} "json:\"total,omitempty\""
			} "json:\"flash,omitempty\""
		})
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExtended(v)
		return nil
	}
	return fmt.Errorf("unknown Stats field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *StatsMutation) AddedFields() []string {
	var fields []string
	if m.addteam_id != nil {
		fields = append(fields, stats.FieldTeamID)
	}
	if m.addkills != nil {
		fields = append(fields, stats.FieldKills)
	}
	if m.adddeaths != nil {
		fields = append(fields, stats.FieldDeaths)
	}
	if m.addassists != nil {
		fields = append(fields, stats.FieldAssists)
	}
	if m.addheadshot != nil {
		fields = append(fields, stats.FieldHeadshot)
	}
	if m.addmvp != nil {
		fields = append(fields, stats.FieldMvp)
	}
	if m.addscore != nil {
		fields = append(fields, stats.FieldScore)
	}
	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 *StatsMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case stats.FieldTeamID:
		return m.AddedTeamID()
	case stats.FieldKills:
		return m.AddedKills()
	case stats.FieldDeaths:
		return m.AddedDeaths()
	case stats.FieldAssists:
		return m.AddedAssists()
	case stats.FieldHeadshot:
		return m.AddedHeadshot()
	case stats.FieldMvp:
		return m.AddedMvp()
	case stats.FieldScore:
		return m.AddedScore()
	}
	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 *StatsMutation) AddField(name string, value ent.Value) error {
	switch name {
	case stats.FieldTeamID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTeamID(v)
		return nil
	case stats.FieldKills:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddKills(v)
		return nil
	case stats.FieldDeaths:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeaths(v)
		return nil
	case stats.FieldAssists:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAssists(v)
		return nil
	case stats.FieldHeadshot:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddHeadshot(v)
		return nil
	case stats.FieldMvp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddMvp(v)
		return nil
	case stats.FieldScore:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddScore(v)
		return nil
	}
	return fmt.Errorf("unknown Stats numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *StatsMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(stats.FieldExtended) {
		fields = append(fields, stats.FieldExtended)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *StatsMutation) 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 *StatsMutation) ClearField(name string) error {
	switch name {
	case stats.FieldExtended:
		m.ClearExtended()
		return nil
	}
	return fmt.Errorf("unknown Stats 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 *StatsMutation) ResetField(name string) error {
	switch name {
	case stats.FieldTeamID:
		m.ResetTeamID()
		return nil
	case stats.FieldKills:
		m.ResetKills()
		return nil
	case stats.FieldDeaths:
		m.ResetDeaths()
		return nil
	case stats.FieldAssists:
		m.ResetAssists()
		return nil
	case stats.FieldHeadshot:
		m.ResetHeadshot()
		return nil
	case stats.FieldMvp:
		m.ResetMvp()
		return nil
	case stats.FieldScore:
		m.ResetScore()
		return nil
	case stats.FieldExtended:
		m.ResetExtended()
		return nil
	}
	return fmt.Errorf("unknown Stats field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *StatsMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.matches != nil {
		edges = append(edges, stats.EdgeMatches)
	}
	if m.players != nil {
		edges = append(edges, stats.EdgePlayers)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *StatsMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case stats.EdgeMatches:
		if id := m.matches; id != nil {
			return []ent.Value{*id}
		}
	case stats.EdgePlayers:
		if id := m.players; id != nil {
			return []ent.Value{*id}
		}
	}
	return nil
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *StatsMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedmatches {
		edges = append(edges, stats.EdgeMatches)
	}
	if m.clearedplayers {
		edges = append(edges, stats.EdgePlayers)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *StatsMutation) EdgeCleared(name string) bool {
	switch name {
	case stats.EdgeMatches:
		return m.clearedmatches
	case stats.EdgePlayers:
		return m.clearedplayers
	}
	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 *StatsMutation) ClearEdge(name string) error {
	switch name {
	case stats.EdgeMatches:
		m.ClearMatches()
		return nil
	case stats.EdgePlayers:
		m.ClearPlayers()
		return nil
	}
	return fmt.Errorf("unknown Stats 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 *StatsMutation) ResetEdge(name string) error {
	switch name {
	case stats.EdgeMatches:
		m.ResetMatches()
		return nil
	case stats.EdgePlayers:
		m.ResetPlayers()
		return nil
	}
	return fmt.Errorf("unknown Stats edge %s", name)
}