mutation.go

// Code generated by ent, DO NOT EDIT.

package db

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

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"github.com/artefactual-sdps/enduro/internal/persistence/ent/db/pkg"
	"github.com/artefactual-sdps/enduro/internal/persistence/ent/db/predicate"
	"github.com/artefactual-sdps/enduro/internal/persistence/ent/db/preservationaction"
	"github.com/artefactual-sdps/enduro/internal/persistence/ent/db/preservationtask"
	"github.com/google/uuid"
)

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

	// Node types.
	TypePkg                = "Pkg"
	TypePreservationAction = "PreservationAction"
	TypePreservationTask   = "PreservationTask"
)

// PkgMutation represents an operation that mutates the Pkg nodes in the graph.
type PkgMutation struct {
	config
	op                          Op
	typ                         string
	id                          *int
	name                        *string
	workflow_id                 *string
	run_id                      *uuid.UUID
	aip_id                      *uuid.UUID
	location_id                 *uuid.UUID
	status                      *int8
	addstatus                   *int8
	created_at                  *time.Time
	started_at                  *time.Time
	completed_at                *time.Time
	clearedFields               map[string]struct{}
	preservation_actions        map[int]struct{}
	removedpreservation_actions map[int]struct{}
	clearedpreservation_actions bool
	done                        bool
	oldValue                    func(context.Context) (*Pkg, error)
	predicates                  []predicate.Pkg
}

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

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

// newPkgMutation creates new mutation for the Pkg entity.
func newPkgMutation(c config, op Op, opts ...pkgOption) *PkgMutation {
	m := &PkgMutation{
		config:        c,
		op:            op,
		typ:           TypePkg,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withPkg sets the old Pkg of the mutation.
func withPkg(node *Pkg) pkgOption {
	return func(m *PkgMutation) {
		m.oldValue = func(context.Context) (*Pkg, 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 PkgMutation) 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 PkgMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("db: 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 *PkgMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *PkgMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Pkg.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 *PkgMutation) SetName(s string) {
	m.name = &s
}

// Name returns the value of the "name" field in the mutation.
func (m *PkgMutation) 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 Pkg entity.
// If the Pkg 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 *PkgMutation) 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 *PkgMutation) ResetName() {
	m.name = nil
}

// SetWorkflowID sets the "workflow_id" field.
func (m *PkgMutation) SetWorkflowID(s string) {
	m.workflow_id = &s
}

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

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

// ResetWorkflowID resets all changes to the "workflow_id" field.
func (m *PkgMutation) ResetWorkflowID() {
	m.workflow_id = nil
}

// SetRunID sets the "run_id" field.
func (m *PkgMutation) SetRunID(u uuid.UUID) {
	m.run_id = &u
}

// RunID returns the value of the "run_id" field in the mutation.
func (m *PkgMutation) RunID() (r uuid.UUID, exists bool) {
	v := m.run_id
	if v == nil {
		return
	}
	return *v, true
}

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

// ResetRunID resets all changes to the "run_id" field.
func (m *PkgMutation) ResetRunID() {
	m.run_id = nil
}

// SetAipID sets the "aip_id" field.
func (m *PkgMutation) SetAipID(u uuid.UUID) {
	m.aip_id = &u
}

// AipID returns the value of the "aip_id" field in the mutation.
func (m *PkgMutation) AipID() (r uuid.UUID, exists bool) {
	v := m.aip_id
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearAipID clears the value of the "aip_id" field.
func (m *PkgMutation) ClearAipID() {
	m.aip_id = nil
	m.clearedFields[pkg.FieldAipID] = struct{}{}
}

// AipIDCleared returns if the "aip_id" field was cleared in this mutation.
func (m *PkgMutation) AipIDCleared() bool {
	_, ok := m.clearedFields[pkg.FieldAipID]
	return ok
}

// ResetAipID resets all changes to the "aip_id" field.
func (m *PkgMutation) ResetAipID() {
	m.aip_id = nil
	delete(m.clearedFields, pkg.FieldAipID)
}

// SetLocationID sets the "location_id" field.
func (m *PkgMutation) SetLocationID(u uuid.UUID) {
	m.location_id = &u
}

// LocationID returns the value of the "location_id" field in the mutation.
func (m *PkgMutation) LocationID() (r uuid.UUID, exists bool) {
	v := m.location_id
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearLocationID clears the value of the "location_id" field.
func (m *PkgMutation) ClearLocationID() {
	m.location_id = nil
	m.clearedFields[pkg.FieldLocationID] = struct{}{}
}

// LocationIDCleared returns if the "location_id" field was cleared in this mutation.
func (m *PkgMutation) LocationIDCleared() bool {
	_, ok := m.clearedFields[pkg.FieldLocationID]
	return ok
}

// ResetLocationID resets all changes to the "location_id" field.
func (m *PkgMutation) ResetLocationID() {
	m.location_id = nil
	delete(m.clearedFields, pkg.FieldLocationID)
}

// SetStatus sets the "status" field.
func (m *PkgMutation) SetStatus(i int8) {
	m.status = &i
	m.addstatus = nil
}

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

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

// AddStatus adds i to the "status" field.
func (m *PkgMutation) AddStatus(i int8) {
	if m.addstatus != nil {
		*m.addstatus += i
	} else {
		m.addstatus = &i
	}
}

// AddedStatus returns the value that was added to the "status" field in this mutation.
func (m *PkgMutation) AddedStatus() (r int8, exists bool) {
	v := m.addstatus
	if v == nil {
		return
	}
	return *v, true
}

// ResetStatus resets all changes to the "status" field.
func (m *PkgMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *PkgMutation) 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 Pkg entity.
// If the Pkg 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 *PkgMutation) 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 *PkgMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetStartedAt sets the "started_at" field.
func (m *PkgMutation) SetStartedAt(t time.Time) {
	m.started_at = &t
}

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

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

// ClearStartedAt clears the value of the "started_at" field.
func (m *PkgMutation) ClearStartedAt() {
	m.started_at = nil
	m.clearedFields[pkg.FieldStartedAt] = struct{}{}
}

// StartedAtCleared returns if the "started_at" field was cleared in this mutation.
func (m *PkgMutation) StartedAtCleared() bool {
	_, ok := m.clearedFields[pkg.FieldStartedAt]
	return ok
}

// ResetStartedAt resets all changes to the "started_at" field.
func (m *PkgMutation) ResetStartedAt() {
	m.started_at = nil
	delete(m.clearedFields, pkg.FieldStartedAt)
}

// SetCompletedAt sets the "completed_at" field.
func (m *PkgMutation) SetCompletedAt(t time.Time) {
	m.completed_at = &t
}

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

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

// ClearCompletedAt clears the value of the "completed_at" field.
func (m *PkgMutation) ClearCompletedAt() {
	m.completed_at = nil
	m.clearedFields[pkg.FieldCompletedAt] = struct{}{}
}

// CompletedAtCleared returns if the "completed_at" field was cleared in this mutation.
func (m *PkgMutation) CompletedAtCleared() bool {
	_, ok := m.clearedFields[pkg.FieldCompletedAt]
	return ok
}

// ResetCompletedAt resets all changes to the "completed_at" field.
func (m *PkgMutation) ResetCompletedAt() {
	m.completed_at = nil
	delete(m.clearedFields, pkg.FieldCompletedAt)
}

// AddPreservationActionIDs adds the "preservation_actions" edge to the PreservationAction entity by ids.
func (m *PkgMutation) AddPreservationActionIDs(ids ...int) {
	if m.preservation_actions == nil {
		m.preservation_actions = make(map[int]struct{})
	}
	for i := range ids {
		m.preservation_actions[ids[i]] = struct{}{}
	}
}

// ClearPreservationActions clears the "preservation_actions" edge to the PreservationAction entity.
func (m *PkgMutation) ClearPreservationActions() {
	m.clearedpreservation_actions = true
}

// PreservationActionsCleared reports if the "preservation_actions" edge to the PreservationAction entity was cleared.
func (m *PkgMutation) PreservationActionsCleared() bool {
	return m.clearedpreservation_actions
}

// RemovePreservationActionIDs removes the "preservation_actions" edge to the PreservationAction entity by IDs.
func (m *PkgMutation) RemovePreservationActionIDs(ids ...int) {
	if m.removedpreservation_actions == nil {
		m.removedpreservation_actions = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.preservation_actions, ids[i])
		m.removedpreservation_actions[ids[i]] = struct{}{}
	}
}

// RemovedPreservationActions returns the removed IDs of the "preservation_actions" edge to the PreservationAction entity.
func (m *PkgMutation) RemovedPreservationActionsIDs() (ids []int) {
	for id := range m.removedpreservation_actions {
		ids = append(ids, id)
	}
	return
}

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

// ResetPreservationActions resets all changes to the "preservation_actions" edge.
func (m *PkgMutation) ResetPreservationActions() {
	m.preservation_actions = nil
	m.clearedpreservation_actions = false
	m.removedpreservation_actions = nil
}

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

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

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

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

// Type returns the node type of this mutation (Pkg).
func (m *PkgMutation) 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 *PkgMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.name != nil {
		fields = append(fields, pkg.FieldName)
	}
	if m.workflow_id != nil {
		fields = append(fields, pkg.FieldWorkflowID)
	}
	if m.run_id != nil {
		fields = append(fields, pkg.FieldRunID)
	}
	if m.aip_id != nil {
		fields = append(fields, pkg.FieldAipID)
	}
	if m.location_id != nil {
		fields = append(fields, pkg.FieldLocationID)
	}
	if m.status != nil {
		fields = append(fields, pkg.FieldStatus)
	}
	if m.created_at != nil {
		fields = append(fields, pkg.FieldCreatedAt)
	}
	if m.started_at != nil {
		fields = append(fields, pkg.FieldStartedAt)
	}
	if m.completed_at != nil {
		fields = append(fields, pkg.FieldCompletedAt)
	}
	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 *PkgMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case pkg.FieldName:
		return m.Name()
	case pkg.FieldWorkflowID:
		return m.WorkflowID()
	case pkg.FieldRunID:
		return m.RunID()
	case pkg.FieldAipID:
		return m.AipID()
	case pkg.FieldLocationID:
		return m.LocationID()
	case pkg.FieldStatus:
		return m.Status()
	case pkg.FieldCreatedAt:
		return m.CreatedAt()
	case pkg.FieldStartedAt:
		return m.StartedAt()
	case pkg.FieldCompletedAt:
		return m.CompletedAt()
	}
	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 *PkgMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case pkg.FieldName:
		return m.OldName(ctx)
	case pkg.FieldWorkflowID:
		return m.OldWorkflowID(ctx)
	case pkg.FieldRunID:
		return m.OldRunID(ctx)
	case pkg.FieldAipID:
		return m.OldAipID(ctx)
	case pkg.FieldLocationID:
		return m.OldLocationID(ctx)
	case pkg.FieldStatus:
		return m.OldStatus(ctx)
	case pkg.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case pkg.FieldStartedAt:
		return m.OldStartedAt(ctx)
	case pkg.FieldCompletedAt:
		return m.OldCompletedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Pkg 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 *PkgMutation) SetField(name string, value ent.Value) error {
	switch name {
	case pkg.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case pkg.FieldWorkflowID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWorkflowID(v)
		return nil
	case pkg.FieldRunID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRunID(v)
		return nil
	case pkg.FieldAipID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAipID(v)
		return nil
	case pkg.FieldLocationID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLocationID(v)
		return nil
	case pkg.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case pkg.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 pkg.FieldStartedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartedAt(v)
		return nil
	case pkg.FieldCompletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Pkg field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *PkgMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(pkg.FieldAipID) {
		fields = append(fields, pkg.FieldAipID)
	}
	if m.FieldCleared(pkg.FieldLocationID) {
		fields = append(fields, pkg.FieldLocationID)
	}
	if m.FieldCleared(pkg.FieldStartedAt) {
		fields = append(fields, pkg.FieldStartedAt)
	}
	if m.FieldCleared(pkg.FieldCompletedAt) {
		fields = append(fields, pkg.FieldCompletedAt)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PkgMutation) 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 *PkgMutation) ClearField(name string) error {
	switch name {
	case pkg.FieldAipID:
		m.ClearAipID()
		return nil
	case pkg.FieldLocationID:
		m.ClearLocationID()
		return nil
	case pkg.FieldStartedAt:
		m.ClearStartedAt()
		return nil
	case pkg.FieldCompletedAt:
		m.ClearCompletedAt()
		return nil
	}
	return fmt.Errorf("unknown Pkg 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 *PkgMutation) ResetField(name string) error {
	switch name {
	case pkg.FieldName:
		m.ResetName()
		return nil
	case pkg.FieldWorkflowID:
		m.ResetWorkflowID()
		return nil
	case pkg.FieldRunID:
		m.ResetRunID()
		return nil
	case pkg.FieldAipID:
		m.ResetAipID()
		return nil
	case pkg.FieldLocationID:
		m.ResetLocationID()
		return nil
	case pkg.FieldStatus:
		m.ResetStatus()
		return nil
	case pkg.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case pkg.FieldStartedAt:
		m.ResetStartedAt()
		return nil
	case pkg.FieldCompletedAt:
		m.ResetCompletedAt()
		return nil
	}
	return fmt.Errorf("unknown Pkg field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *PkgMutation) AddedEdges() []string {
	edges := make([]string, 0, 1)
	if m.preservation_actions != nil {
		edges = append(edges, pkg.EdgePreservationActions)
	}
	return edges
}

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

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *PkgMutation) RemovedEdges() []string {
	edges := make([]string, 0, 1)
	if m.removedpreservation_actions != nil {
		edges = append(edges, pkg.EdgePreservationActions)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PkgMutation) ClearedEdges() []string {
	edges := make([]string, 0, 1)
	if m.clearedpreservation_actions {
		edges = append(edges, pkg.EdgePreservationActions)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *PkgMutation) EdgeCleared(name string) bool {
	switch name {
	case pkg.EdgePreservationActions:
		return m.clearedpreservation_actions
	}
	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 *PkgMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Pkg 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 *PkgMutation) ResetEdge(name string) error {
	switch name {
	case pkg.EdgePreservationActions:
		m.ResetPreservationActions()
		return nil
	}
	return fmt.Errorf("unknown Pkg edge %s", name)
}

// PreservationActionMutation represents an operation that mutates the PreservationAction nodes in the graph.
type PreservationActionMutation struct {
	config
	op              Op
	typ             string
	id              *int
	workflow_id     *string
	_type           *int8
	add_type        *int8
	status          *int8
	addstatus       *int8
	started_at      *time.Time
	completed_at    *time.Time
	clearedFields   map[string]struct{}
	_package        *int
	cleared_package bool
	tasks           map[int]struct{}
	removedtasks    map[int]struct{}
	clearedtasks    bool
	done            bool
	oldValue        func(context.Context) (*PreservationAction, error)
	predicates      []predicate.PreservationAction
}

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

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

// newPreservationActionMutation creates new mutation for the PreservationAction entity.
func newPreservationActionMutation(c config, op Op, opts ...preservationactionOption) *PreservationActionMutation {
	m := &PreservationActionMutation{
		config:        c,
		op:            op,
		typ:           TypePreservationAction,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withPreservationAction sets the old PreservationAction of the mutation.
func withPreservationAction(node *PreservationAction) preservationactionOption {
	return func(m *PreservationActionMutation) {
		m.oldValue = func(context.Context) (*PreservationAction, 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 PreservationActionMutation) 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 PreservationActionMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("db: 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 *PreservationActionMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

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

// SetWorkflowID sets the "workflow_id" field.
func (m *PreservationActionMutation) SetWorkflowID(s string) {
	m.workflow_id = &s
}

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

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

// ResetWorkflowID resets all changes to the "workflow_id" field.
func (m *PreservationActionMutation) ResetWorkflowID() {
	m.workflow_id = nil
}

// SetType sets the "type" field.
func (m *PreservationActionMutation) SetType(i int8) {
	m._type = &i
	m.add_type = nil
}

// GetType returns the value of the "type" field in the mutation.
func (m *PreservationActionMutation) GetType() (r int8, exists bool) {
	v := m._type
	if v == nil {
		return
	}
	return *v, true
}

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

// AddType adds i to the "type" field.
func (m *PreservationActionMutation) AddType(i int8) {
	if m.add_type != nil {
		*m.add_type += i
	} else {
		m.add_type = &i
	}
}

// AddedType returns the value that was added to the "type" field in this mutation.
func (m *PreservationActionMutation) AddedType() (r int8, exists bool) {
	v := m.add_type
	if v == nil {
		return
	}
	return *v, true
}

// ResetType resets all changes to the "type" field.
func (m *PreservationActionMutation) ResetType() {
	m._type = nil
	m.add_type = nil
}

// SetStatus sets the "status" field.
func (m *PreservationActionMutation) SetStatus(i int8) {
	m.status = &i
	m.addstatus = nil
}

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

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

// AddStatus adds i to the "status" field.
func (m *PreservationActionMutation) AddStatus(i int8) {
	if m.addstatus != nil {
		*m.addstatus += i
	} else {
		m.addstatus = &i
	}
}

// AddedStatus returns the value that was added to the "status" field in this mutation.
func (m *PreservationActionMutation) AddedStatus() (r int8, exists bool) {
	v := m.addstatus
	if v == nil {
		return
	}
	return *v, true
}

// ResetStatus resets all changes to the "status" field.
func (m *PreservationActionMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
}

// SetStartedAt sets the "started_at" field.
func (m *PreservationActionMutation) SetStartedAt(t time.Time) {
	m.started_at = &t
}

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

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

// ClearStartedAt clears the value of the "started_at" field.
func (m *PreservationActionMutation) ClearStartedAt() {
	m.started_at = nil
	m.clearedFields[preservationaction.FieldStartedAt] = struct{}{}
}

// StartedAtCleared returns if the "started_at" field was cleared in this mutation.
func (m *PreservationActionMutation) StartedAtCleared() bool {
	_, ok := m.clearedFields[preservationaction.FieldStartedAt]
	return ok
}

// ResetStartedAt resets all changes to the "started_at" field.
func (m *PreservationActionMutation) ResetStartedAt() {
	m.started_at = nil
	delete(m.clearedFields, preservationaction.FieldStartedAt)
}

// SetCompletedAt sets the "completed_at" field.
func (m *PreservationActionMutation) SetCompletedAt(t time.Time) {
	m.completed_at = &t
}

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

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

// ClearCompletedAt clears the value of the "completed_at" field.
func (m *PreservationActionMutation) ClearCompletedAt() {
	m.completed_at = nil
	m.clearedFields[preservationaction.FieldCompletedAt] = struct{}{}
}

// CompletedAtCleared returns if the "completed_at" field was cleared in this mutation.
func (m *PreservationActionMutation) CompletedAtCleared() bool {
	_, ok := m.clearedFields[preservationaction.FieldCompletedAt]
	return ok
}

// ResetCompletedAt resets all changes to the "completed_at" field.
func (m *PreservationActionMutation) ResetCompletedAt() {
	m.completed_at = nil
	delete(m.clearedFields, preservationaction.FieldCompletedAt)
}

// SetPackageID sets the "package_id" field.
func (m *PreservationActionMutation) SetPackageID(i int) {
	m._package = &i
}

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

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

// ResetPackageID resets all changes to the "package_id" field.
func (m *PreservationActionMutation) ResetPackageID() {
	m._package = nil
}

// ClearPackage clears the "package" edge to the Pkg entity.
func (m *PreservationActionMutation) ClearPackage() {
	m.cleared_package = true
	m.clearedFields[preservationaction.FieldPackageID] = struct{}{}
}

// PackageCleared reports if the "package" edge to the Pkg entity was cleared.
func (m *PreservationActionMutation) PackageCleared() bool {
	return m.cleared_package
}

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

// ResetPackage resets all changes to the "package" edge.
func (m *PreservationActionMutation) ResetPackage() {
	m._package = nil
	m.cleared_package = false
}

// AddTaskIDs adds the "tasks" edge to the PreservationTask entity by ids.
func (m *PreservationActionMutation) AddTaskIDs(ids ...int) {
	if m.tasks == nil {
		m.tasks = make(map[int]struct{})
	}
	for i := range ids {
		m.tasks[ids[i]] = struct{}{}
	}
}

// ClearTasks clears the "tasks" edge to the PreservationTask entity.
func (m *PreservationActionMutation) ClearTasks() {
	m.clearedtasks = true
}

// TasksCleared reports if the "tasks" edge to the PreservationTask entity was cleared.
func (m *PreservationActionMutation) TasksCleared() bool {
	return m.clearedtasks
}

// RemoveTaskIDs removes the "tasks" edge to the PreservationTask entity by IDs.
func (m *PreservationActionMutation) RemoveTaskIDs(ids ...int) {
	if m.removedtasks == nil {
		m.removedtasks = make(map[int]struct{})
	}
	for i := range ids {
		delete(m.tasks, ids[i])
		m.removedtasks[ids[i]] = struct{}{}
	}
}

// RemovedTasks returns the removed IDs of the "tasks" edge to the PreservationTask entity.
func (m *PreservationActionMutation) RemovedTasksIDs() (ids []int) {
	for id := range m.removedtasks {
		ids = append(ids, id)
	}
	return
}

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

// ResetTasks resets all changes to the "tasks" edge.
func (m *PreservationActionMutation) ResetTasks() {
	m.tasks = nil
	m.clearedtasks = false
	m.removedtasks = nil
}

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

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

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

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

// Type returns the node type of this mutation (PreservationAction).
func (m *PreservationActionMutation) 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 *PreservationActionMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.workflow_id != nil {
		fields = append(fields, preservationaction.FieldWorkflowID)
	}
	if m._type != nil {
		fields = append(fields, preservationaction.FieldType)
	}
	if m.status != nil {
		fields = append(fields, preservationaction.FieldStatus)
	}
	if m.started_at != nil {
		fields = append(fields, preservationaction.FieldStartedAt)
	}
	if m.completed_at != nil {
		fields = append(fields, preservationaction.FieldCompletedAt)
	}
	if m._package != nil {
		fields = append(fields, preservationaction.FieldPackageID)
	}
	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 *PreservationActionMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case preservationaction.FieldWorkflowID:
		return m.WorkflowID()
	case preservationaction.FieldType:
		return m.GetType()
	case preservationaction.FieldStatus:
		return m.Status()
	case preservationaction.FieldStartedAt:
		return m.StartedAt()
	case preservationaction.FieldCompletedAt:
		return m.CompletedAt()
	case preservationaction.FieldPackageID:
		return m.PackageID()
	}
	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 *PreservationActionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case preservationaction.FieldWorkflowID:
		return m.OldWorkflowID(ctx)
	case preservationaction.FieldType:
		return m.OldType(ctx)
	case preservationaction.FieldStatus:
		return m.OldStatus(ctx)
	case preservationaction.FieldStartedAt:
		return m.OldStartedAt(ctx)
	case preservationaction.FieldCompletedAt:
		return m.OldCompletedAt(ctx)
	case preservationaction.FieldPackageID:
		return m.OldPackageID(ctx)
	}
	return nil, fmt.Errorf("unknown PreservationAction 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 *PreservationActionMutation) SetField(name string, value ent.Value) error {
	switch name {
	case preservationaction.FieldWorkflowID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWorkflowID(v)
		return nil
	case preservationaction.FieldType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case preservationaction.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case preservationaction.FieldStartedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartedAt(v)
		return nil
	case preservationaction.FieldCompletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompletedAt(v)
		return nil
	case preservationaction.FieldPackageID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPackageID(v)
		return nil
	}
	return fmt.Errorf("unknown PreservationAction field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *PreservationActionMutation) AddedFields() []string {
	var fields []string
	if m.add_type != nil {
		fields = append(fields, preservationaction.FieldType)
	}
	if m.addstatus != nil {
		fields = append(fields, preservationaction.FieldStatus)
	}
	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 *PreservationActionMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case preservationaction.FieldType:
		return m.AddedType()
	case preservationaction.FieldStatus:
		return m.AddedStatus()
	}
	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 *PreservationActionMutation) AddField(name string, value ent.Value) error {
	switch name {
	case preservationaction.FieldType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case preservationaction.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	}
	return fmt.Errorf("unknown PreservationAction numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PreservationActionMutation) 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 *PreservationActionMutation) ClearField(name string) error {
	switch name {
	case preservationaction.FieldStartedAt:
		m.ClearStartedAt()
		return nil
	case preservationaction.FieldCompletedAt:
		m.ClearCompletedAt()
		return nil
	}
	return fmt.Errorf("unknown PreservationAction 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 *PreservationActionMutation) ResetField(name string) error {
	switch name {
	case preservationaction.FieldWorkflowID:
		m.ResetWorkflowID()
		return nil
	case preservationaction.FieldType:
		m.ResetType()
		return nil
	case preservationaction.FieldStatus:
		m.ResetStatus()
		return nil
	case preservationaction.FieldStartedAt:
		m.ResetStartedAt()
		return nil
	case preservationaction.FieldCompletedAt:
		m.ResetCompletedAt()
		return nil
	case preservationaction.FieldPackageID:
		m.ResetPackageID()
		return nil
	}
	return fmt.Errorf("unknown PreservationAction field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *PreservationActionMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m._package != nil {
		edges = append(edges, preservationaction.EdgePackage)
	}
	if m.tasks != nil {
		edges = append(edges, preservationaction.EdgeTasks)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *PreservationActionMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case preservationaction.EdgePackage:
		if id := m._package; id != nil {
			return []ent.Value{*id}
		}
	case preservationaction.EdgeTasks:
		ids := make([]ent.Value, 0, len(m.tasks))
		for id := range m.tasks {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *PreservationActionMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedtasks != nil {
		edges = append(edges, preservationaction.EdgeTasks)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PreservationActionMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.cleared_package {
		edges = append(edges, preservationaction.EdgePackage)
	}
	if m.clearedtasks {
		edges = append(edges, preservationaction.EdgeTasks)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *PreservationActionMutation) EdgeCleared(name string) bool {
	switch name {
	case preservationaction.EdgePackage:
		return m.cleared_package
	case preservationaction.EdgeTasks:
		return m.clearedtasks
	}
	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 *PreservationActionMutation) ClearEdge(name string) error {
	switch name {
	case preservationaction.EdgePackage:
		m.ClearPackage()
		return nil
	}
	return fmt.Errorf("unknown PreservationAction 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 *PreservationActionMutation) ResetEdge(name string) error {
	switch name {
	case preservationaction.EdgePackage:
		m.ResetPackage()
		return nil
	case preservationaction.EdgeTasks:
		m.ResetTasks()
		return nil
	}
	return fmt.Errorf("unknown PreservationAction edge %s", name)
}

// PreservationTaskMutation represents an operation that mutates the PreservationTask nodes in the graph.
type PreservationTaskMutation struct {
	config
	op            Op
	typ           string
	id            *int
	task_id       *uuid.UUID
	name          *string
	status        *int8
	addstatus     *int8
	started_at    *time.Time
	completed_at  *time.Time
	note          *string
	clearedFields map[string]struct{}
	action        *int
	clearedaction bool
	done          bool
	oldValue      func(context.Context) (*PreservationTask, error)
	predicates    []predicate.PreservationTask
}

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

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

// newPreservationTaskMutation creates new mutation for the PreservationTask entity.
func newPreservationTaskMutation(c config, op Op, opts ...preservationtaskOption) *PreservationTaskMutation {
	m := &PreservationTaskMutation{
		config:        c,
		op:            op,
		typ:           TypePreservationTask,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withPreservationTask sets the old PreservationTask of the mutation.
func withPreservationTask(node *PreservationTask) preservationtaskOption {
	return func(m *PreservationTaskMutation) {
		m.oldValue = func(context.Context) (*PreservationTask, 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 PreservationTaskMutation) 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 PreservationTaskMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("db: 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 *PreservationTaskMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

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

// SetTaskID sets the "task_id" field.
func (m *PreservationTaskMutation) SetTaskID(u uuid.UUID) {
	m.task_id = &u
}

// TaskID returns the value of the "task_id" field in the mutation.
func (m *PreservationTaskMutation) TaskID() (r uuid.UUID, exists bool) {
	v := m.task_id
	if v == nil {
		return
	}
	return *v, true
}

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

// ResetTaskID resets all changes to the "task_id" field.
func (m *PreservationTaskMutation) ResetTaskID() {
	m.task_id = nil
}

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

// Name returns the value of the "name" field in the mutation.
func (m *PreservationTaskMutation) 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 PreservationTask entity.
// If the PreservationTask 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 *PreservationTaskMutation) 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 *PreservationTaskMutation) ResetName() {
	m.name = nil
}

// SetStatus sets the "status" field.
func (m *PreservationTaskMutation) SetStatus(i int8) {
	m.status = &i
	m.addstatus = nil
}

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

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

// AddStatus adds i to the "status" field.
func (m *PreservationTaskMutation) AddStatus(i int8) {
	if m.addstatus != nil {
		*m.addstatus += i
	} else {
		m.addstatus = &i
	}
}

// AddedStatus returns the value that was added to the "status" field in this mutation.
func (m *PreservationTaskMutation) AddedStatus() (r int8, exists bool) {
	v := m.addstatus
	if v == nil {
		return
	}
	return *v, true
}

// ResetStatus resets all changes to the "status" field.
func (m *PreservationTaskMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
}

// SetStartedAt sets the "started_at" field.
func (m *PreservationTaskMutation) SetStartedAt(t time.Time) {
	m.started_at = &t
}

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

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

// ClearStartedAt clears the value of the "started_at" field.
func (m *PreservationTaskMutation) ClearStartedAt() {
	m.started_at = nil
	m.clearedFields[preservationtask.FieldStartedAt] = struct{}{}
}

// StartedAtCleared returns if the "started_at" field was cleared in this mutation.
func (m *PreservationTaskMutation) StartedAtCleared() bool {
	_, ok := m.clearedFields[preservationtask.FieldStartedAt]
	return ok
}

// ResetStartedAt resets all changes to the "started_at" field.
func (m *PreservationTaskMutation) ResetStartedAt() {
	m.started_at = nil
	delete(m.clearedFields, preservationtask.FieldStartedAt)
}

// SetCompletedAt sets the "completed_at" field.
func (m *PreservationTaskMutation) SetCompletedAt(t time.Time) {
	m.completed_at = &t
}

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

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

// ClearCompletedAt clears the value of the "completed_at" field.
func (m *PreservationTaskMutation) ClearCompletedAt() {
	m.completed_at = nil
	m.clearedFields[preservationtask.FieldCompletedAt] = struct{}{}
}

// CompletedAtCleared returns if the "completed_at" field was cleared in this mutation.
func (m *PreservationTaskMutation) CompletedAtCleared() bool {
	_, ok := m.clearedFields[preservationtask.FieldCompletedAt]
	return ok
}

// ResetCompletedAt resets all changes to the "completed_at" field.
func (m *PreservationTaskMutation) ResetCompletedAt() {
	m.completed_at = nil
	delete(m.clearedFields, preservationtask.FieldCompletedAt)
}

// SetNote sets the "note" field.
func (m *PreservationTaskMutation) SetNote(s string) {
	m.note = &s
}

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

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

// ResetNote resets all changes to the "note" field.
func (m *PreservationTaskMutation) ResetNote() {
	m.note = nil
}

// SetPreservationActionID sets the "preservation_action_id" field.
func (m *PreservationTaskMutation) SetPreservationActionID(i int) {
	m.action = &i
}

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

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

// ResetPreservationActionID resets all changes to the "preservation_action_id" field.
func (m *PreservationTaskMutation) ResetPreservationActionID() {
	m.action = nil
}

// SetActionID sets the "action" edge to the PreservationAction entity by id.
func (m *PreservationTaskMutation) SetActionID(id int) {
	m.action = &id
}

// ClearAction clears the "action" edge to the PreservationAction entity.
func (m *PreservationTaskMutation) ClearAction() {
	m.clearedaction = true
	m.clearedFields[preservationtask.FieldPreservationActionID] = struct{}{}
}

// ActionCleared reports if the "action" edge to the PreservationAction entity was cleared.
func (m *PreservationTaskMutation) ActionCleared() bool {
	return m.clearedaction
}

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

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

// ResetAction resets all changes to the "action" edge.
func (m *PreservationTaskMutation) ResetAction() {
	m.action = nil
	m.clearedaction = false
}

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

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

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

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

// Type returns the node type of this mutation (PreservationTask).
func (m *PreservationTaskMutation) 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 *PreservationTaskMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.task_id != nil {
		fields = append(fields, preservationtask.FieldTaskID)
	}
	if m.name != nil {
		fields = append(fields, preservationtask.FieldName)
	}
	if m.status != nil {
		fields = append(fields, preservationtask.FieldStatus)
	}
	if m.started_at != nil {
		fields = append(fields, preservationtask.FieldStartedAt)
	}
	if m.completed_at != nil {
		fields = append(fields, preservationtask.FieldCompletedAt)
	}
	if m.note != nil {
		fields = append(fields, preservationtask.FieldNote)
	}
	if m.action != nil {
		fields = append(fields, preservationtask.FieldPreservationActionID)
	}
	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 *PreservationTaskMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case preservationtask.FieldTaskID:
		return m.TaskID()
	case preservationtask.FieldName:
		return m.Name()
	case preservationtask.FieldStatus:
		return m.Status()
	case preservationtask.FieldStartedAt:
		return m.StartedAt()
	case preservationtask.FieldCompletedAt:
		return m.CompletedAt()
	case preservationtask.FieldNote:
		return m.Note()
	case preservationtask.FieldPreservationActionID:
		return m.PreservationActionID()
	}
	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 *PreservationTaskMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case preservationtask.FieldTaskID:
		return m.OldTaskID(ctx)
	case preservationtask.FieldName:
		return m.OldName(ctx)
	case preservationtask.FieldStatus:
		return m.OldStatus(ctx)
	case preservationtask.FieldStartedAt:
		return m.OldStartedAt(ctx)
	case preservationtask.FieldCompletedAt:
		return m.OldCompletedAt(ctx)
	case preservationtask.FieldNote:
		return m.OldNote(ctx)
	case preservationtask.FieldPreservationActionID:
		return m.OldPreservationActionID(ctx)
	}
	return nil, fmt.Errorf("unknown PreservationTask 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 *PreservationTaskMutation) SetField(name string, value ent.Value) error {
	switch name {
	case preservationtask.FieldTaskID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTaskID(v)
		return nil
	case preservationtask.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case preservationtask.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case preservationtask.FieldStartedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartedAt(v)
		return nil
	case preservationtask.FieldCompletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompletedAt(v)
		return nil
	case preservationtask.FieldNote:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNote(v)
		return nil
	case preservationtask.FieldPreservationActionID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPreservationActionID(v)
		return nil
	}
	return fmt.Errorf("unknown PreservationTask field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PreservationTaskMutation) 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 *PreservationTaskMutation) ClearField(name string) error {
	switch name {
	case preservationtask.FieldStartedAt:
		m.ClearStartedAt()
		return nil
	case preservationtask.FieldCompletedAt:
		m.ClearCompletedAt()
		return nil
	}
	return fmt.Errorf("unknown PreservationTask 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 *PreservationTaskMutation) ResetField(name string) error {
	switch name {
	case preservationtask.FieldTaskID:
		m.ResetTaskID()
		return nil
	case preservationtask.FieldName:
		m.ResetName()
		return nil
	case preservationtask.FieldStatus:
		m.ResetStatus()
		return nil
	case preservationtask.FieldStartedAt:
		m.ResetStartedAt()
		return nil
	case preservationtask.FieldCompletedAt:
		m.ResetCompletedAt()
		return nil
	case preservationtask.FieldNote:
		m.ResetNote()
		return nil
	case preservationtask.FieldPreservationActionID:
		m.ResetPreservationActionID()
		return nil
	}
	return fmt.Errorf("unknown PreservationTask field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *PreservationTaskMutation) AddedEdges() []string {
	edges := make([]string, 0, 1)
	if m.action != nil {
		edges = append(edges, preservationtask.EdgeAction)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PreservationTaskMutation) ClearedEdges() []string {
	edges := make([]string, 0, 1)
	if m.clearedaction {
		edges = append(edges, preservationtask.EdgeAction)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *PreservationTaskMutation) EdgeCleared(name string) bool {
	switch name {
	case preservationtask.EdgeAction:
		return m.clearedaction
	}
	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 *PreservationTaskMutation) ClearEdge(name string) error {
	switch name {
	case preservationtask.EdgeAction:
		m.ClearAction()
		return nil
	}
	return fmt.Errorf("unknown PreservationTask 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 *PreservationTaskMutation) ResetEdge(name string) error {
	switch name {
	case preservationtask.EdgeAction:
		m.ResetAction()
		return nil
	}
	return fmt.Errorf("unknown PreservationTask edge %s", name)
}