pcmt/ent/mutation.go

// Code generated by ent, DO NOT EDIT.

package ent

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

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"git.dotya.ml/mirre-mt/pcmt/ent/hibp"
	"git.dotya.ml/mirre-mt/pcmt/ent/predicate"
	"git.dotya.ml/mirre-mt/pcmt/ent/setup"
	"git.dotya.ml/mirre-mt/pcmt/ent/user"
	"github.com/google/uuid"
)

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

	// Node types.
	TypeHIBP  = "HIBP"
	TypeSetup = "Setup"
	TypeUser  = "User"
)

// HIBPMutation represents an operation that mutates the HIBP nodes in the graph.
type HIBPMutation struct {
	config
	op                Op
	typ               string
	id                *uuid.UUID
	name              *string
	domain            *string
	breach_date       *time.Time
	added_date        *time.Time
	modified_date     *time.Time
	pwn_count         *int
	addpwn_count      *int
	description       *string
	dataclasses       *[]string
	appenddataclasses []string
	is_verified       *bool
	is_fabricated     *bool
	is_sensitive      *bool
	is_retired        *bool
	is_spamList       *bool
	is_malware        *bool
	logo              *string
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*HIBP, error)
	predicates        []predicate.HIBP
}

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

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

// newHIBPMutation creates new mutation for the HIBP entity.
func newHIBPMutation(c config, op Op, opts ...hibpOption) *HIBPMutation {
	m := &HIBPMutation{
		config:        c,
		op:            op,
		typ:           TypeHIBP,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withHIBP sets the old HIBP of the mutation.
func withHIBP(node *HIBP) hibpOption {
	return func(m *HIBPMutation) {
		m.oldValue = func(context.Context) (*HIBP, 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 HIBPMutation) 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 HIBPMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of HIBP entities.
func (m *HIBPMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *HIBPMutation) ID() (id uuid.UUID, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

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

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

// Name returns the value of the "name" field in the mutation.
func (m *HIBPMutation) 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 HIBP entity.
// If the HIBP 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 *HIBPMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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
}

// ResetName resets all changes to the "name" field.
func (m *HIBPMutation) ResetName() {
	m.name = nil
}

// SetDomain sets the "domain" field.
func (m *HIBPMutation) SetDomain(s string) {
	m.domain = &s
}

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

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

// ResetDomain resets all changes to the "domain" field.
func (m *HIBPMutation) ResetDomain() {
	m.domain = nil
}

// SetBreachDate sets the "breach_date" field.
func (m *HIBPMutation) SetBreachDate(t time.Time) {
	m.breach_date = &t
}

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

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

// ResetBreachDate resets all changes to the "breach_date" field.
func (m *HIBPMutation) ResetBreachDate() {
	m.breach_date = nil
}

// SetAddedDate sets the "added_date" field.
func (m *HIBPMutation) SetAddedDate(t time.Time) {
	m.added_date = &t
}

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

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

// ResetAddedDate resets all changes to the "added_date" field.
func (m *HIBPMutation) ResetAddedDate() {
	m.added_date = nil
}

// SetModifiedDate sets the "modified_date" field.
func (m *HIBPMutation) SetModifiedDate(t time.Time) {
	m.modified_date = &t
}

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

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

// ResetModifiedDate resets all changes to the "modified_date" field.
func (m *HIBPMutation) ResetModifiedDate() {
	m.modified_date = nil
}

// SetPwnCount sets the "pwn_count" field.
func (m *HIBPMutation) SetPwnCount(i int) {
	m.pwn_count = &i
	m.addpwn_count = nil
}

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

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

// AddPwnCount adds i to the "pwn_count" field.
func (m *HIBPMutation) AddPwnCount(i int) {
	if m.addpwn_count != nil {
		*m.addpwn_count += i
	} else {
		m.addpwn_count = &i
	}
}

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

// ResetPwnCount resets all changes to the "pwn_count" field.
func (m *HIBPMutation) ResetPwnCount() {
	m.pwn_count = nil
	m.addpwn_count = nil
}

// SetDescription sets the "description" field.
func (m *HIBPMutation) SetDescription(s string) {
	m.description = &s
}

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

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

// ResetDescription resets all changes to the "description" field.
func (m *HIBPMutation) ResetDescription() {
	m.description = nil
}

// SetDataclasses sets the "dataclasses" field.
func (m *HIBPMutation) SetDataclasses(s []string) {
	m.dataclasses = &s
	m.appenddataclasses = nil
}

// Dataclasses returns the value of the "dataclasses" field in the mutation.
func (m *HIBPMutation) Dataclasses() (r []string, exists bool) {
	v := m.dataclasses
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendDataclasses adds s to the "dataclasses" field.
func (m *HIBPMutation) AppendDataclasses(s []string) {
	m.appenddataclasses = append(m.appenddataclasses, s...)
}

// AppendedDataclasses returns the list of values that were appended to the "dataclasses" field in this mutation.
func (m *HIBPMutation) AppendedDataclasses() ([]string, bool) {
	if len(m.appenddataclasses) == 0 {
		return nil, false
	}
	return m.appenddataclasses, true
}

// ResetDataclasses resets all changes to the "dataclasses" field.
func (m *HIBPMutation) ResetDataclasses() {
	m.dataclasses = nil
	m.appenddataclasses = nil
}

// SetIsVerified sets the "is_verified" field.
func (m *HIBPMutation) SetIsVerified(b bool) {
	m.is_verified = &b
}

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

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

// ResetIsVerified resets all changes to the "is_verified" field.
func (m *HIBPMutation) ResetIsVerified() {
	m.is_verified = nil
}

// SetIsFabricated sets the "is_fabricated" field.
func (m *HIBPMutation) SetIsFabricated(b bool) {
	m.is_fabricated = &b
}

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

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

// ResetIsFabricated resets all changes to the "is_fabricated" field.
func (m *HIBPMutation) ResetIsFabricated() {
	m.is_fabricated = nil
}

// SetIsSensitive sets the "is_sensitive" field.
func (m *HIBPMutation) SetIsSensitive(b bool) {
	m.is_sensitive = &b
}

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

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

// ResetIsSensitive resets all changes to the "is_sensitive" field.
func (m *HIBPMutation) ResetIsSensitive() {
	m.is_sensitive = nil
}

// SetIsRetired sets the "is_retired" field.
func (m *HIBPMutation) SetIsRetired(b bool) {
	m.is_retired = &b
}

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

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

// ResetIsRetired resets all changes to the "is_retired" field.
func (m *HIBPMutation) ResetIsRetired() {
	m.is_retired = nil
}

// SetIsSpamList sets the "is_spamList" field.
func (m *HIBPMutation) SetIsSpamList(b bool) {
	m.is_spamList = &b
}

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

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

// ResetIsSpamList resets all changes to the "is_spamList" field.
func (m *HIBPMutation) ResetIsSpamList() {
	m.is_spamList = nil
}

// SetIsMalware sets the "is_malware" field.
func (m *HIBPMutation) SetIsMalware(b bool) {
	m.is_malware = &b
}

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

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

// ResetIsMalware resets all changes to the "is_malware" field.
func (m *HIBPMutation) ResetIsMalware() {
	m.is_malware = nil
}

// SetLogo sets the "logo" field.
func (m *HIBPMutation) SetLogo(s string) {
	m.logo = &s
}

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

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

// ResetLogo resets all changes to the "logo" field.
func (m *HIBPMutation) ResetLogo() {
	m.logo = nil
}

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

// WhereP appends storage-level predicates to the HIBPMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *HIBPMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.HIBP, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

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

// SetOp allows setting the mutation operation.
func (m *HIBPMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (HIBP).
func (m *HIBPMutation) 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 *HIBPMutation) Fields() []string {
	fields := make([]string, 0, 15)
	if m.name != nil {
		fields = append(fields, hibp.FieldName)
	}
	if m.domain != nil {
		fields = append(fields, hibp.FieldDomain)
	}
	if m.breach_date != nil {
		fields = append(fields, hibp.FieldBreachDate)
	}
	if m.added_date != nil {
		fields = append(fields, hibp.FieldAddedDate)
	}
	if m.modified_date != nil {
		fields = append(fields, hibp.FieldModifiedDate)
	}
	if m.pwn_count != nil {
		fields = append(fields, hibp.FieldPwnCount)
	}
	if m.description != nil {
		fields = append(fields, hibp.FieldDescription)
	}
	if m.dataclasses != nil {
		fields = append(fields, hibp.FieldDataclasses)
	}
	if m.is_verified != nil {
		fields = append(fields, hibp.FieldIsVerified)
	}
	if m.is_fabricated != nil {
		fields = append(fields, hibp.FieldIsFabricated)
	}
	if m.is_sensitive != nil {
		fields = append(fields, hibp.FieldIsSensitive)
	}
	if m.is_retired != nil {
		fields = append(fields, hibp.FieldIsRetired)
	}
	if m.is_spamList != nil {
		fields = append(fields, hibp.FieldIsSpamList)
	}
	if m.is_malware != nil {
		fields = append(fields, hibp.FieldIsMalware)
	}
	if m.logo != nil {
		fields = append(fields, hibp.FieldLogo)
	}
	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 *HIBPMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case hibp.FieldName:
		return m.Name()
	case hibp.FieldDomain:
		return m.Domain()
	case hibp.FieldBreachDate:
		return m.BreachDate()
	case hibp.FieldAddedDate:
		return m.AddedDate()
	case hibp.FieldModifiedDate:
		return m.ModifiedDate()
	case hibp.FieldPwnCount:
		return m.PwnCount()
	case hibp.FieldDescription:
		return m.Description()
	case hibp.FieldDataclasses:
		return m.Dataclasses()
	case hibp.FieldIsVerified:
		return m.IsVerified()
	case hibp.FieldIsFabricated:
		return m.IsFabricated()
	case hibp.FieldIsSensitive:
		return m.IsSensitive()
	case hibp.FieldIsRetired:
		return m.IsRetired()
	case hibp.FieldIsSpamList:
		return m.IsSpamList()
	case hibp.FieldIsMalware:
		return m.IsMalware()
	case hibp.FieldLogo:
		return m.Logo()
	}
	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 *HIBPMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case hibp.FieldName:
		return m.OldName(ctx)
	case hibp.FieldDomain:
		return m.OldDomain(ctx)
	case hibp.FieldBreachDate:
		return m.OldBreachDate(ctx)
	case hibp.FieldAddedDate:
		return m.OldAddedDate(ctx)
	case hibp.FieldModifiedDate:
		return m.OldModifiedDate(ctx)
	case hibp.FieldPwnCount:
		return m.OldPwnCount(ctx)
	case hibp.FieldDescription:
		return m.OldDescription(ctx)
	case hibp.FieldDataclasses:
		return m.OldDataclasses(ctx)
	case hibp.FieldIsVerified:
		return m.OldIsVerified(ctx)
	case hibp.FieldIsFabricated:
		return m.OldIsFabricated(ctx)
	case hibp.FieldIsSensitive:
		return m.OldIsSensitive(ctx)
	case hibp.FieldIsRetired:
		return m.OldIsRetired(ctx)
	case hibp.FieldIsSpamList:
		return m.OldIsSpamList(ctx)
	case hibp.FieldIsMalware:
		return m.OldIsMalware(ctx)
	case hibp.FieldLogo:
		return m.OldLogo(ctx)
	}
	return nil, fmt.Errorf("unknown HIBP 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 *HIBPMutation) SetField(name string, value ent.Value) error {
	switch name {
	case hibp.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case hibp.FieldDomain:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDomain(v)
		return nil
	case hibp.FieldBreachDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBreachDate(v)
		return nil
	case hibp.FieldAddedDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAddedDate(v)
		return nil
	case hibp.FieldModifiedDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetModifiedDate(v)
		return nil
	case hibp.FieldPwnCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPwnCount(v)
		return nil
	case hibp.FieldDescription:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDescription(v)
		return nil
	case hibp.FieldDataclasses:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDataclasses(v)
		return nil
	case hibp.FieldIsVerified:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsVerified(v)
		return nil
	case hibp.FieldIsFabricated:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsFabricated(v)
		return nil
	case hibp.FieldIsSensitive:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsSensitive(v)
		return nil
	case hibp.FieldIsRetired:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsRetired(v)
		return nil
	case hibp.FieldIsSpamList:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsSpamList(v)
		return nil
	case hibp.FieldIsMalware:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsMalware(v)
		return nil
	case hibp.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	}
	return fmt.Errorf("unknown HIBP field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *HIBPMutation) AddedFields() []string {
	var fields []string
	if m.addpwn_count != nil {
		fields = append(fields, hibp.FieldPwnCount)
	}
	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 *HIBPMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case hibp.FieldPwnCount:
		return m.AddedPwnCount()
	}
	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 *HIBPMutation) AddField(name string, value ent.Value) error {
	switch name {
	case hibp.FieldPwnCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPwnCount(v)
		return nil
	}
	return fmt.Errorf("unknown HIBP numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *HIBPMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *HIBPMutation) 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 *HIBPMutation) ClearField(name string) error {
	return fmt.Errorf("unknown HIBP 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 *HIBPMutation) ResetField(name string) error {
	switch name {
	case hibp.FieldName:
		m.ResetName()
		return nil
	case hibp.FieldDomain:
		m.ResetDomain()
		return nil
	case hibp.FieldBreachDate:
		m.ResetBreachDate()
		return nil
	case hibp.FieldAddedDate:
		m.ResetAddedDate()
		return nil
	case hibp.FieldModifiedDate:
		m.ResetModifiedDate()
		return nil
	case hibp.FieldPwnCount:
		m.ResetPwnCount()
		return nil
	case hibp.FieldDescription:
		m.ResetDescription()
		return nil
	case hibp.FieldDataclasses:
		m.ResetDataclasses()
		return nil
	case hibp.FieldIsVerified:
		m.ResetIsVerified()
		return nil
	case hibp.FieldIsFabricated:
		m.ResetIsFabricated()
		return nil
	case hibp.FieldIsSensitive:
		m.ResetIsSensitive()
		return nil
	case hibp.FieldIsRetired:
		m.ResetIsRetired()
		return nil
	case hibp.FieldIsSpamList:
		m.ResetIsSpamList()
		return nil
	case hibp.FieldIsMalware:
		m.ResetIsMalware()
		return nil
	case hibp.FieldLogo:
		m.ResetLogo()
		return nil
	}
	return fmt.Errorf("unknown HIBP field %s", name)
}

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

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

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

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

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

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

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *HIBPMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown HIBP 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 *HIBPMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown HIBP edge %s", name)
}

// SetupMutation represents an operation that mutates the Setup nodes in the graph.
type SetupMutation struct {
	config
	op            Op
	typ           string
	id            *uuid.UUID
	set_up_at     *time.Time
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Setup, error)
	predicates    []predicate.Setup
}

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

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

// newSetupMutation creates new mutation for the Setup entity.
func newSetupMutation(c config, op Op, opts ...setupOption) *SetupMutation {
	m := &SetupMutation{
		config:        c,
		op:            op,
		typ:           TypeSetup,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withSetup sets the old Setup of the mutation.
func withSetup(node *Setup) setupOption {
	return func(m *SetupMutation) {
		m.oldValue = func(context.Context) (*Setup, 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 SetupMutation) 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 SetupMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Setup entities.
func (m *SetupMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *SetupMutation) ID() (id uuid.UUID, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

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

// SetSetUpAt sets the "set_up_at" field.
func (m *SetupMutation) SetSetUpAt(t time.Time) {
	m.set_up_at = &t
}

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

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

// ResetSetUpAt resets all changes to the "set_up_at" field.
func (m *SetupMutation) ResetSetUpAt() {
	m.set_up_at = nil
}

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

// WhereP appends storage-level predicates to the SetupMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *SetupMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.Setup, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

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

// SetOp allows setting the mutation operation.
func (m *SetupMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (Setup).
func (m *SetupMutation) 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 *SetupMutation) Fields() []string {
	fields := make([]string, 0, 1)
	if m.set_up_at != nil {
		fields = append(fields, setup.FieldSetUpAt)
	}
	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 *SetupMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case setup.FieldSetUpAt:
		return m.SetUpAt()
	}
	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 *SetupMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case setup.FieldSetUpAt:
		return m.OldSetUpAt(ctx)
	}
	return nil, fmt.Errorf("unknown Setup 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 *SetupMutation) SetField(name string, value ent.Value) error {
	switch name {
	case setup.FieldSetUpAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSetUpAt(v)
		return nil
	}
	return fmt.Errorf("unknown Setup field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *SetupMutation) AddedFields() []string {
	return nil
}

// 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 *SetupMutation) AddedField(name string) (ent.Value, bool) {
	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 *SetupMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Setup numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *SetupMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *SetupMutation) 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 *SetupMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Setup 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 *SetupMutation) ResetField(name string) error {
	switch name {
	case setup.FieldSetUpAt:
		m.ResetSetUpAt()
		return nil
	}
	return fmt.Errorf("unknown Setup field %s", name)
}

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

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

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

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

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

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

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *SetupMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Setup 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 *SetupMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Setup edge %s", name)
}

// UserMutation represents an operation that mutates the User nodes in the graph.
type UserMutation struct {
	config
	op            Op
	typ           string
	id            *uuid.UUID
	username      *string
	email         *string
	password      *[]byte
	is_admin      *bool
	is_active     *bool
	created_at    *time.Time
	updated_at    *time.Time
	last_login    *time.Time
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*User, error)
	predicates    []predicate.User
}

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

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

// newUserMutation creates new mutation for the User entity.
func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
	m := &UserMutation{
		config:        c,
		op:            op,
		typ:           TypeUser,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withUser sets the old User of the mutation.
func withUser(node *User) userOption {
	return func(m *UserMutation) {
		m.oldValue = func(context.Context) (*User, 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 UserMutation) 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 UserMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of User entities.
func (m *UserMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *UserMutation) ID() (id uuid.UUID, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

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

// SetUsername sets the "username" field.
func (m *UserMutation) SetUsername(s string) {
	m.username = &s
}

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

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

// ResetUsername resets all changes to the "username" field.
func (m *UserMutation) ResetUsername() {
	m.username = nil
}

// SetEmail sets the "email" field.
func (m *UserMutation) SetEmail(s string) {
	m.email = &s
}

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

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

// ResetEmail resets all changes to the "email" field.
func (m *UserMutation) ResetEmail() {
	m.email = nil
}

// SetPassword sets the "password" field.
func (m *UserMutation) SetPassword(b []byte) {
	m.password = &b
}

// Password returns the value of the "password" field in the mutation.
func (m *UserMutation) Password() (r []byte, exists bool) {
	v := m.password
	if v == nil {
		return
	}
	return *v, true
}

// OldPassword returns the old "password" field's value of the User entity.
// If the User 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 *UserMutation) OldPassword(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPassword is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPassword requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPassword: %w", err)
	}
	return oldValue.Password, nil
}

// ResetPassword resets all changes to the "password" field.
func (m *UserMutation) ResetPassword() {
	m.password = nil
}

// SetIsAdmin sets the "is_admin" field.
func (m *UserMutation) SetIsAdmin(b bool) {
	m.is_admin = &b
}

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

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

// ResetIsAdmin resets all changes to the "is_admin" field.
func (m *UserMutation) ResetIsAdmin() {
	m.is_admin = nil
}

// SetIsActive sets the "is_active" field.
func (m *UserMutation) SetIsActive(b bool) {
	m.is_active = &b
}

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

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

// ResetIsActive resets all changes to the "is_active" field.
func (m *UserMutation) ResetIsActive() {
	m.is_active = nil
}

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

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

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

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *UserMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

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

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

// ResetUpdatedAt resets all changes to the "updated_at" field.
func (m *UserMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetLastLogin sets the "last_login" field.
func (m *UserMutation) SetLastLogin(t time.Time) {
	m.last_login = &t
}

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

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

// ResetLastLogin resets all changes to the "last_login" field.
func (m *UserMutation) ResetLastLogin() {
	m.last_login = nil
}

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

// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.User, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

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

// SetOp allows setting the mutation operation.
func (m *UserMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (User).
func (m *UserMutation) 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 *UserMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.username != nil {
		fields = append(fields, user.FieldUsername)
	}
	if m.email != nil {
		fields = append(fields, user.FieldEmail)
	}
	if m.password != nil {
		fields = append(fields, user.FieldPassword)
	}
	if m.is_admin != nil {
		fields = append(fields, user.FieldIsAdmin)
	}
	if m.is_active != nil {
		fields = append(fields, user.FieldIsActive)
	}
	if m.created_at != nil {
		fields = append(fields, user.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, user.FieldUpdatedAt)
	}
	if m.last_login != nil {
		fields = append(fields, user.FieldLastLogin)
	}
	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 *UserMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case user.FieldUsername:
		return m.Username()
	case user.FieldEmail:
		return m.Email()
	case user.FieldPassword:
		return m.Password()
	case user.FieldIsAdmin:
		return m.IsAdmin()
	case user.FieldIsActive:
		return m.IsActive()
	case user.FieldCreatedAt:
		return m.CreatedAt()
	case user.FieldUpdatedAt:
		return m.UpdatedAt()
	case user.FieldLastLogin:
		return m.LastLogin()
	}
	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 *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case user.FieldUsername:
		return m.OldUsername(ctx)
	case user.FieldEmail:
		return m.OldEmail(ctx)
	case user.FieldPassword:
		return m.OldPassword(ctx)
	case user.FieldIsAdmin:
		return m.OldIsAdmin(ctx)
	case user.FieldIsActive:
		return m.OldIsActive(ctx)
	case user.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case user.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case user.FieldLastLogin:
		return m.OldLastLogin(ctx)
	}
	return nil, fmt.Errorf("unknown User 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 *UserMutation) SetField(name string, value ent.Value) error {
	switch name {
	case user.FieldUsername:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUsername(v)
		return nil
	case user.FieldEmail:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmail(v)
		return nil
	case user.FieldPassword:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPassword(v)
		return nil
	case user.FieldIsAdmin:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsAdmin(v)
		return nil
	case user.FieldIsActive:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsActive(v)
		return nil
	case user.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case user.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case user.FieldLastLogin:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLastLogin(v)
		return nil
	}
	return fmt.Errorf("unknown User field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UserMutation) AddedFields() []string {
	return nil
}

// 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 *UserMutation) AddedField(name string) (ent.Value, bool) {
	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 *UserMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown User numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *UserMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UserMutation) 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 *UserMutation) ClearField(name string) error {
	return fmt.Errorf("unknown User 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 *UserMutation) ResetField(name string) error {
	switch name {
	case user.FieldUsername:
		m.ResetUsername()
		return nil
	case user.FieldEmail:
		m.ResetEmail()
		return nil
	case user.FieldPassword:
		m.ResetPassword()
		return nil
	case user.FieldIsAdmin:
		m.ResetIsAdmin()
		return nil
	case user.FieldIsActive:
		m.ResetIsActive()
		return nil
	case user.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case user.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case user.FieldLastLogin:
		m.ResetLastLogin()
		return nil
	}
	return fmt.Errorf("unknown User field %s", name)
}

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

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

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

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

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

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

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *UserMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown User 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 *UserMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown User edge %s", name)
}