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"
	"github.com/ugent-library/old-people-service/ent/organization"
	"github.com/ugent-library/old-people-service/ent/organizationparent"
	"github.com/ugent-library/old-people-service/ent/organizationperson"
	"github.com/ugent-library/old-people-service/ent/person"
	"github.com/ugent-library/old-people-service/ent/predicate"
)

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

	// Node types.
	TypeOrganization       = "Organization"
	TypeOrganizationParent = "OrganizationParent"
	TypeOrganizationPerson = "OrganizationPerson"
	TypePerson             = "Person"
)

// OrganizationMutation represents an operation that mutates the Organization nodes in the graph.
type OrganizationMutation struct {
	config
	op                      Op
	typ                     string
	id                      *int
	date_created            *time.Time
	date_updated            *time.Time
	public_id               *string
	identifier              *[]string
	appendidentifier        []string
	identifier_values       *[]string
	appendidentifier_values []string
	_type                   *string
	acronym                 *string
	name_dut                *string
	name_eng                *string
	clearedFields           map[string]struct{}
	done                    bool
	oldValue                func(context.Context) (*Organization, error)
	predicates              []predicate.Organization
}

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

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

// newOrganizationMutation creates new mutation for the Organization entity.
func newOrganizationMutation(c config, op Op, opts ...organizationOption) *OrganizationMutation {
	m := &OrganizationMutation{
		config:        c,
		op:            op,
		typ:           TypeOrganization,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *OrganizationMutation) 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 *OrganizationMutation) 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().Organization.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetDateCreated sets the "date_created" field.
func (m *OrganizationMutation) SetDateCreated(t time.Time) {
	m.date_created = &t
}

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

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

// ResetDateCreated resets all changes to the "date_created" field.
func (m *OrganizationMutation) ResetDateCreated() {
	m.date_created = nil
}

// SetDateUpdated sets the "date_updated" field.
func (m *OrganizationMutation) SetDateUpdated(t time.Time) {
	m.date_updated = &t
}

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

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

// ResetDateUpdated resets all changes to the "date_updated" field.
func (m *OrganizationMutation) ResetDateUpdated() {
	m.date_updated = nil
}

// SetPublicID sets the "public_id" field.
func (m *OrganizationMutation) SetPublicID(s string) {
	m.public_id = &s
}

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

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

// ResetPublicID resets all changes to the "public_id" field.
func (m *OrganizationMutation) ResetPublicID() {
	m.public_id = nil
}

// SetIdentifier sets the "identifier" field.
func (m *OrganizationMutation) SetIdentifier(s []string) {
	m.identifier = &s
	m.appendidentifier = nil
}

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

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

// AppendIdentifier adds s to the "identifier" field.
func (m *OrganizationMutation) AppendIdentifier(s []string) {
	m.appendidentifier = append(m.appendidentifier, s...)
}

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

// ClearIdentifier clears the value of the "identifier" field.
func (m *OrganizationMutation) ClearIdentifier() {
	m.identifier = nil
	m.appendidentifier = nil
	m.clearedFields[organization.FieldIdentifier] = struct{}{}
}

// IdentifierCleared returns if the "identifier" field was cleared in this mutation.
func (m *OrganizationMutation) IdentifierCleared() bool {
	_, ok := m.clearedFields[organization.FieldIdentifier]
	return ok
}

// ResetIdentifier resets all changes to the "identifier" field.
func (m *OrganizationMutation) ResetIdentifier() {
	m.identifier = nil
	m.appendidentifier = nil
	delete(m.clearedFields, organization.FieldIdentifier)
}

// SetIdentifierValues sets the "identifier_values" field.
func (m *OrganizationMutation) SetIdentifierValues(s []string) {
	m.identifier_values = &s
	m.appendidentifier_values = nil
}

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

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

// AppendIdentifierValues adds s to the "identifier_values" field.
func (m *OrganizationMutation) AppendIdentifierValues(s []string) {
	m.appendidentifier_values = append(m.appendidentifier_values, s...)
}

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

// ClearIdentifierValues clears the value of the "identifier_values" field.
func (m *OrganizationMutation) ClearIdentifierValues() {
	m.identifier_values = nil
	m.appendidentifier_values = nil
	m.clearedFields[organization.FieldIdentifierValues] = struct{}{}
}

// IdentifierValuesCleared returns if the "identifier_values" field was cleared in this mutation.
func (m *OrganizationMutation) IdentifierValuesCleared() bool {
	_, ok := m.clearedFields[organization.FieldIdentifierValues]
	return ok
}

// ResetIdentifierValues resets all changes to the "identifier_values" field.
func (m *OrganizationMutation) ResetIdentifierValues() {
	m.identifier_values = nil
	m.appendidentifier_values = nil
	delete(m.clearedFields, organization.FieldIdentifierValues)
}

// SetType sets the "type" field.
func (m *OrganizationMutation) SetType(s string) {
	m._type = &s
}

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

// OldType returns the old "type" field's value of the Organization entity.
// If the Organization 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 *OrganizationMutation) OldType(ctx context.Context) (v string, 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
}

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

// SetAcronym sets the "acronym" field.
func (m *OrganizationMutation) SetAcronym(s string) {
	m.acronym = &s
}

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

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

// ClearAcronym clears the value of the "acronym" field.
func (m *OrganizationMutation) ClearAcronym() {
	m.acronym = nil
	m.clearedFields[organization.FieldAcronym] = struct{}{}
}

// AcronymCleared returns if the "acronym" field was cleared in this mutation.
func (m *OrganizationMutation) AcronymCleared() bool {
	_, ok := m.clearedFields[organization.FieldAcronym]
	return ok
}

// ResetAcronym resets all changes to the "acronym" field.
func (m *OrganizationMutation) ResetAcronym() {
	m.acronym = nil
	delete(m.clearedFields, organization.FieldAcronym)
}

// SetNameDut sets the "name_dut" field.
func (m *OrganizationMutation) SetNameDut(s string) {
	m.name_dut = &s
}

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

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

// ClearNameDut clears the value of the "name_dut" field.
func (m *OrganizationMutation) ClearNameDut() {
	m.name_dut = nil
	m.clearedFields[organization.FieldNameDut] = struct{}{}
}

// NameDutCleared returns if the "name_dut" field was cleared in this mutation.
func (m *OrganizationMutation) NameDutCleared() bool {
	_, ok := m.clearedFields[organization.FieldNameDut]
	return ok
}

// ResetNameDut resets all changes to the "name_dut" field.
func (m *OrganizationMutation) ResetNameDut() {
	m.name_dut = nil
	delete(m.clearedFields, organization.FieldNameDut)
}

// SetNameEng sets the "name_eng" field.
func (m *OrganizationMutation) SetNameEng(s string) {
	m.name_eng = &s
}

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

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

// ClearNameEng clears the value of the "name_eng" field.
func (m *OrganizationMutation) ClearNameEng() {
	m.name_eng = nil
	m.clearedFields[organization.FieldNameEng] = struct{}{}
}

// NameEngCleared returns if the "name_eng" field was cleared in this mutation.
func (m *OrganizationMutation) NameEngCleared() bool {
	_, ok := m.clearedFields[organization.FieldNameEng]
	return ok
}

// ResetNameEng resets all changes to the "name_eng" field.
func (m *OrganizationMutation) ResetNameEng() {
	m.name_eng = nil
	delete(m.clearedFields, organization.FieldNameEng)
}

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

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

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

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

// Type returns the node type of this mutation (Organization).
func (m *OrganizationMutation) 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 *OrganizationMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.date_created != nil {
		fields = append(fields, organization.FieldDateCreated)
	}
	if m.date_updated != nil {
		fields = append(fields, organization.FieldDateUpdated)
	}
	if m.public_id != nil {
		fields = append(fields, organization.FieldPublicID)
	}
	if m.identifier != nil {
		fields = append(fields, organization.FieldIdentifier)
	}
	if m.identifier_values != nil {
		fields = append(fields, organization.FieldIdentifierValues)
	}
	if m._type != nil {
		fields = append(fields, organization.FieldType)
	}
	if m.acronym != nil {
		fields = append(fields, organization.FieldAcronym)
	}
	if m.name_dut != nil {
		fields = append(fields, organization.FieldNameDut)
	}
	if m.name_eng != nil {
		fields = append(fields, organization.FieldNameEng)
	}
	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 *OrganizationMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case organization.FieldDateCreated:
		return m.DateCreated()
	case organization.FieldDateUpdated:
		return m.DateUpdated()
	case organization.FieldPublicID:
		return m.PublicID()
	case organization.FieldIdentifier:
		return m.Identifier()
	case organization.FieldIdentifierValues:
		return m.IdentifierValues()
	case organization.FieldType:
		return m.GetType()
	case organization.FieldAcronym:
		return m.Acronym()
	case organization.FieldNameDut:
		return m.NameDut()
	case organization.FieldNameEng:
		return m.NameEng()
	}
	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 *OrganizationMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case organization.FieldDateCreated:
		return m.OldDateCreated(ctx)
	case organization.FieldDateUpdated:
		return m.OldDateUpdated(ctx)
	case organization.FieldPublicID:
		return m.OldPublicID(ctx)
	case organization.FieldIdentifier:
		return m.OldIdentifier(ctx)
	case organization.FieldIdentifierValues:
		return m.OldIdentifierValues(ctx)
	case organization.FieldType:
		return m.OldType(ctx)
	case organization.FieldAcronym:
		return m.OldAcronym(ctx)
	case organization.FieldNameDut:
		return m.OldNameDut(ctx)
	case organization.FieldNameEng:
		return m.OldNameEng(ctx)
	}
	return nil, fmt.Errorf("unknown Organization 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 *OrganizationMutation) SetField(name string, value ent.Value) error {
	switch name {
	case organization.FieldDateCreated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateCreated(v)
		return nil
	case organization.FieldDateUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateUpdated(v)
		return nil
	case organization.FieldPublicID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPublicID(v)
		return nil
	case organization.FieldIdentifier:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIdentifier(v)
		return nil
	case organization.FieldIdentifierValues:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIdentifierValues(v)
		return nil
	case organization.FieldType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case organization.FieldAcronym:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAcronym(v)
		return nil
	case organization.FieldNameDut:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNameDut(v)
		return nil
	case organization.FieldNameEng:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNameEng(v)
		return nil
	}
	return fmt.Errorf("unknown Organization field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) 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 *OrganizationMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Organization numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *OrganizationMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(organization.FieldIdentifier) {
		fields = append(fields, organization.FieldIdentifier)
	}
	if m.FieldCleared(organization.FieldIdentifierValues) {
		fields = append(fields, organization.FieldIdentifierValues)
	}
	if m.FieldCleared(organization.FieldAcronym) {
		fields = append(fields, organization.FieldAcronym)
	}
	if m.FieldCleared(organization.FieldNameDut) {
		fields = append(fields, organization.FieldNameDut)
	}
	if m.FieldCleared(organization.FieldNameEng) {
		fields = append(fields, organization.FieldNameEng)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) ClearField(name string) error {
	switch name {
	case organization.FieldIdentifier:
		m.ClearIdentifier()
		return nil
	case organization.FieldIdentifierValues:
		m.ClearIdentifierValues()
		return nil
	case organization.FieldAcronym:
		m.ClearAcronym()
		return nil
	case organization.FieldNameDut:
		m.ClearNameDut()
		return nil
	case organization.FieldNameEng:
		m.ClearNameEng()
		return nil
	}
	return fmt.Errorf("unknown Organization 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 *OrganizationMutation) ResetField(name string) error {
	switch name {
	case organization.FieldDateCreated:
		m.ResetDateCreated()
		return nil
	case organization.FieldDateUpdated:
		m.ResetDateUpdated()
		return nil
	case organization.FieldPublicID:
		m.ResetPublicID()
		return nil
	case organization.FieldIdentifier:
		m.ResetIdentifier()
		return nil
	case organization.FieldIdentifierValues:
		m.ResetIdentifierValues()
		return nil
	case organization.FieldType:
		m.ResetType()
		return nil
	case organization.FieldAcronym:
		m.ResetAcronym()
		return nil
	case organization.FieldNameDut:
		m.ResetNameDut()
		return nil
	case organization.FieldNameEng:
		m.ResetNameEng()
		return nil
	}
	return fmt.Errorf("unknown Organization field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) 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 *OrganizationMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Organization 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 *OrganizationMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Organization edge %s", name)
}

// OrganizationParentMutation represents an operation that mutates the OrganizationParent nodes in the graph.
type OrganizationParentMutation struct {
	config
	op                        Op
	typ                       string
	id                        *int
	date_created              *time.Time
	date_updated              *time.Time
	parent_organization_id    *int
	addparent_organization_id *int
	organization_id           *int
	addorganization_id        *int
	from                      *time.Time
	until                     *time.Time
	clearedFields             map[string]struct{}
	done                      bool
	oldValue                  func(context.Context) (*OrganizationParent, error)
	predicates                []predicate.OrganizationParent
}

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

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

// newOrganizationParentMutation creates new mutation for the OrganizationParent entity.
func newOrganizationParentMutation(c config, op Op, opts ...organizationparentOption) *OrganizationParentMutation {
	m := &OrganizationParentMutation{
		config:        c,
		op:            op,
		typ:           TypeOrganizationParent,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) 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().OrganizationParent.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetDateCreated sets the "date_created" field.
func (m *OrganizationParentMutation) SetDateCreated(t time.Time) {
	m.date_created = &t
}

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

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

// ResetDateCreated resets all changes to the "date_created" field.
func (m *OrganizationParentMutation) ResetDateCreated() {
	m.date_created = nil
}

// SetDateUpdated sets the "date_updated" field.
func (m *OrganizationParentMutation) SetDateUpdated(t time.Time) {
	m.date_updated = &t
}

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

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

// ResetDateUpdated resets all changes to the "date_updated" field.
func (m *OrganizationParentMutation) ResetDateUpdated() {
	m.date_updated = nil
}

// SetParentOrganizationID sets the "parent_organization_id" field.
func (m *OrganizationParentMutation) SetParentOrganizationID(i int) {
	m.parent_organization_id = &i
	m.addparent_organization_id = nil
}

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

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

// AddParentOrganizationID adds i to the "parent_organization_id" field.
func (m *OrganizationParentMutation) AddParentOrganizationID(i int) {
	if m.addparent_organization_id != nil {
		*m.addparent_organization_id += i
	} else {
		m.addparent_organization_id = &i
	}
}

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

// ResetParentOrganizationID resets all changes to the "parent_organization_id" field.
func (m *OrganizationParentMutation) ResetParentOrganizationID() {
	m.parent_organization_id = nil
	m.addparent_organization_id = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *OrganizationParentMutation) SetOrganizationID(i int) {
	m.organization_id = &i
	m.addorganization_id = nil
}

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

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

// AddOrganizationID adds i to the "organization_id" field.
func (m *OrganizationParentMutation) AddOrganizationID(i int) {
	if m.addorganization_id != nil {
		*m.addorganization_id += i
	} else {
		m.addorganization_id = &i
	}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *OrganizationParentMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

// SetFrom sets the "from" field.
func (m *OrganizationParentMutation) SetFrom(t time.Time) {
	m.from = &t
}

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

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

// ResetFrom resets all changes to the "from" field.
func (m *OrganizationParentMutation) ResetFrom() {
	m.from = nil
}

// SetUntil sets the "until" field.
func (m *OrganizationParentMutation) SetUntil(t time.Time) {
	m.until = &t
}

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

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

// ClearUntil clears the value of the "until" field.
func (m *OrganizationParentMutation) ClearUntil() {
	m.until = nil
	m.clearedFields[organizationparent.FieldUntil] = struct{}{}
}

// UntilCleared returns if the "until" field was cleared in this mutation.
func (m *OrganizationParentMutation) UntilCleared() bool {
	_, ok := m.clearedFields[organizationparent.FieldUntil]
	return ok
}

// ResetUntil resets all changes to the "until" field.
func (m *OrganizationParentMutation) ResetUntil() {
	m.until = nil
	delete(m.clearedFields, organizationparent.FieldUntil)
}

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

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

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

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

// Type returns the node type of this mutation (OrganizationParent).
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.date_created != nil {
		fields = append(fields, organizationparent.FieldDateCreated)
	}
	if m.date_updated != nil {
		fields = append(fields, organizationparent.FieldDateUpdated)
	}
	if m.parent_organization_id != nil {
		fields = append(fields, organizationparent.FieldParentOrganizationID)
	}
	if m.organization_id != nil {
		fields = append(fields, organizationparent.FieldOrganizationID)
	}
	if m.from != nil {
		fields = append(fields, organizationparent.FieldFrom)
	}
	if m.until != nil {
		fields = append(fields, organizationparent.FieldUntil)
	}
	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 *OrganizationParentMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case organizationparent.FieldDateCreated:
		return m.DateCreated()
	case organizationparent.FieldDateUpdated:
		return m.DateUpdated()
	case organizationparent.FieldParentOrganizationID:
		return m.ParentOrganizationID()
	case organizationparent.FieldOrganizationID:
		return m.OrganizationID()
	case organizationparent.FieldFrom:
		return m.From()
	case organizationparent.FieldUntil:
		return m.Until()
	}
	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 *OrganizationParentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case organizationparent.FieldDateCreated:
		return m.OldDateCreated(ctx)
	case organizationparent.FieldDateUpdated:
		return m.OldDateUpdated(ctx)
	case organizationparent.FieldParentOrganizationID:
		return m.OldParentOrganizationID(ctx)
	case organizationparent.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case organizationparent.FieldFrom:
		return m.OldFrom(ctx)
	case organizationparent.FieldUntil:
		return m.OldUntil(ctx)
	}
	return nil, fmt.Errorf("unknown OrganizationParent 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 *OrganizationParentMutation) SetField(name string, value ent.Value) error {
	switch name {
	case organizationparent.FieldDateCreated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateCreated(v)
		return nil
	case organizationparent.FieldDateUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateUpdated(v)
		return nil
	case organizationparent.FieldParentOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetParentOrganizationID(v)
		return nil
	case organizationparent.FieldOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case organizationparent.FieldFrom:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFrom(v)
		return nil
	case organizationparent.FieldUntil:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUntil(v)
		return nil
	}
	return fmt.Errorf("unknown OrganizationParent field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OrganizationParentMutation) AddedFields() []string {
	var fields []string
	if m.addparent_organization_id != nil {
		fields = append(fields, organizationparent.FieldParentOrganizationID)
	}
	if m.addorganization_id != nil {
		fields = append(fields, organizationparent.FieldOrganizationID)
	}
	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 *OrganizationParentMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case organizationparent.FieldParentOrganizationID:
		return m.AddedParentOrganizationID()
	case organizationparent.FieldOrganizationID:
		return m.AddedOrganizationID()
	}
	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 *OrganizationParentMutation) AddField(name string, value ent.Value) error {
	switch name {
	case organizationparent.FieldParentOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddParentOrganizationID(v)
		return nil
	case organizationparent.FieldOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown OrganizationParent numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) ClearField(name string) error {
	switch name {
	case organizationparent.FieldUntil:
		m.ClearUntil()
		return nil
	}
	return fmt.Errorf("unknown OrganizationParent 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 *OrganizationParentMutation) ResetField(name string) error {
	switch name {
	case organizationparent.FieldDateCreated:
		m.ResetDateCreated()
		return nil
	case organizationparent.FieldDateUpdated:
		m.ResetDateUpdated()
		return nil
	case organizationparent.FieldParentOrganizationID:
		m.ResetParentOrganizationID()
		return nil
	case organizationparent.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case organizationparent.FieldFrom:
		m.ResetFrom()
		return nil
	case organizationparent.FieldUntil:
		m.ResetUntil()
		return nil
	}
	return fmt.Errorf("unknown OrganizationParent field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *OrganizationParentMutation) 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 *OrganizationParentMutation) 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 *OrganizationParentMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown OrganizationParent 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 *OrganizationParentMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown OrganizationParent edge %s", name)
}

// OrganizationPersonMutation represents an operation that mutates the OrganizationPerson nodes in the graph.
type OrganizationPersonMutation struct {
	config
	op                 Op
	typ                string
	id                 *int
	date_created       *time.Time
	date_updated       *time.Time
	organization_id    *int
	addorganization_id *int
	person_id          *int
	addperson_id       *int
	from               *time.Time
	until              *time.Time
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*OrganizationPerson, error)
	predicates         []predicate.OrganizationPerson
}

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

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

// newOrganizationPersonMutation creates new mutation for the OrganizationPerson entity.
func newOrganizationPersonMutation(c config, op Op, opts ...organizationpersonOption) *OrganizationPersonMutation {
	m := &OrganizationPersonMutation{
		config:        c,
		op:            op,
		typ:           TypeOrganizationPerson,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) 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().OrganizationPerson.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetDateCreated sets the "date_created" field.
func (m *OrganizationPersonMutation) SetDateCreated(t time.Time) {
	m.date_created = &t
}

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

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

// ResetDateCreated resets all changes to the "date_created" field.
func (m *OrganizationPersonMutation) ResetDateCreated() {
	m.date_created = nil
}

// SetDateUpdated sets the "date_updated" field.
func (m *OrganizationPersonMutation) SetDateUpdated(t time.Time) {
	m.date_updated = &t
}

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

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

// ResetDateUpdated resets all changes to the "date_updated" field.
func (m *OrganizationPersonMutation) ResetDateUpdated() {
	m.date_updated = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *OrganizationPersonMutation) SetOrganizationID(i int) {
	m.organization_id = &i
	m.addorganization_id = nil
}

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

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

// AddOrganizationID adds i to the "organization_id" field.
func (m *OrganizationPersonMutation) AddOrganizationID(i int) {
	if m.addorganization_id != nil {
		*m.addorganization_id += i
	} else {
		m.addorganization_id = &i
	}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *OrganizationPersonMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

// SetPersonID sets the "person_id" field.
func (m *OrganizationPersonMutation) SetPersonID(i int) {
	m.person_id = &i
	m.addperson_id = nil
}

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

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

// AddPersonID adds i to the "person_id" field.
func (m *OrganizationPersonMutation) AddPersonID(i int) {
	if m.addperson_id != nil {
		*m.addperson_id += i
	} else {
		m.addperson_id = &i
	}
}

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

// ResetPersonID resets all changes to the "person_id" field.
func (m *OrganizationPersonMutation) ResetPersonID() {
	m.person_id = nil
	m.addperson_id = nil
}

// SetFrom sets the "from" field.
func (m *OrganizationPersonMutation) SetFrom(t time.Time) {
	m.from = &t
}

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

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

// ResetFrom resets all changes to the "from" field.
func (m *OrganizationPersonMutation) ResetFrom() {
	m.from = nil
}

// SetUntil sets the "until" field.
func (m *OrganizationPersonMutation) SetUntil(t time.Time) {
	m.until = &t
}

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

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

// ClearUntil clears the value of the "until" field.
func (m *OrganizationPersonMutation) ClearUntil() {
	m.until = nil
	m.clearedFields[organizationperson.FieldUntil] = struct{}{}
}

// UntilCleared returns if the "until" field was cleared in this mutation.
func (m *OrganizationPersonMutation) UntilCleared() bool {
	_, ok := m.clearedFields[organizationperson.FieldUntil]
	return ok
}

// ResetUntil resets all changes to the "until" field.
func (m *OrganizationPersonMutation) ResetUntil() {
	m.until = nil
	delete(m.clearedFields, organizationperson.FieldUntil)
}

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

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

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

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

// Type returns the node type of this mutation (OrganizationPerson).
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.date_created != nil {
		fields = append(fields, organizationperson.FieldDateCreated)
	}
	if m.date_updated != nil {
		fields = append(fields, organizationperson.FieldDateUpdated)
	}
	if m.organization_id != nil {
		fields = append(fields, organizationperson.FieldOrganizationID)
	}
	if m.person_id != nil {
		fields = append(fields, organizationperson.FieldPersonID)
	}
	if m.from != nil {
		fields = append(fields, organizationperson.FieldFrom)
	}
	if m.until != nil {
		fields = append(fields, organizationperson.FieldUntil)
	}
	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 *OrganizationPersonMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case organizationperson.FieldDateCreated:
		return m.DateCreated()
	case organizationperson.FieldDateUpdated:
		return m.DateUpdated()
	case organizationperson.FieldOrganizationID:
		return m.OrganizationID()
	case organizationperson.FieldPersonID:
		return m.PersonID()
	case organizationperson.FieldFrom:
		return m.From()
	case organizationperson.FieldUntil:
		return m.Until()
	}
	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 *OrganizationPersonMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case organizationperson.FieldDateCreated:
		return m.OldDateCreated(ctx)
	case organizationperson.FieldDateUpdated:
		return m.OldDateUpdated(ctx)
	case organizationperson.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case organizationperson.FieldPersonID:
		return m.OldPersonID(ctx)
	case organizationperson.FieldFrom:
		return m.OldFrom(ctx)
	case organizationperson.FieldUntil:
		return m.OldUntil(ctx)
	}
	return nil, fmt.Errorf("unknown OrganizationPerson 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 *OrganizationPersonMutation) SetField(name string, value ent.Value) error {
	switch name {
	case organizationperson.FieldDateCreated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateCreated(v)
		return nil
	case organizationperson.FieldDateUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateUpdated(v)
		return nil
	case organizationperson.FieldOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case organizationperson.FieldPersonID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPersonID(v)
		return nil
	case organizationperson.FieldFrom:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFrom(v)
		return nil
	case organizationperson.FieldUntil:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUntil(v)
		return nil
	}
	return fmt.Errorf("unknown OrganizationPerson field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OrganizationPersonMutation) AddedFields() []string {
	var fields []string
	if m.addorganization_id != nil {
		fields = append(fields, organizationperson.FieldOrganizationID)
	}
	if m.addperson_id != nil {
		fields = append(fields, organizationperson.FieldPersonID)
	}
	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 *OrganizationPersonMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case organizationperson.FieldOrganizationID:
		return m.AddedOrganizationID()
	case organizationperson.FieldPersonID:
		return m.AddedPersonID()
	}
	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 *OrganizationPersonMutation) AddField(name string, value ent.Value) error {
	switch name {
	case organizationperson.FieldOrganizationID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case organizationperson.FieldPersonID:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPersonID(v)
		return nil
	}
	return fmt.Errorf("unknown OrganizationPerson numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) ClearField(name string) error {
	switch name {
	case organizationperson.FieldUntil:
		m.ClearUntil()
		return nil
	}
	return fmt.Errorf("unknown OrganizationPerson 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 *OrganizationPersonMutation) ResetField(name string) error {
	switch name {
	case organizationperson.FieldDateCreated:
		m.ResetDateCreated()
		return nil
	case organizationperson.FieldDateUpdated:
		m.ResetDateUpdated()
		return nil
	case organizationperson.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case organizationperson.FieldPersonID:
		m.ResetPersonID()
		return nil
	case organizationperson.FieldFrom:
		m.ResetFrom()
		return nil
	case organizationperson.FieldUntil:
		m.ResetUntil()
		return nil
	}
	return fmt.Errorf("unknown OrganizationPerson field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *OrganizationPersonMutation) 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 *OrganizationPersonMutation) 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 *OrganizationPersonMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown OrganizationPerson 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 *OrganizationPersonMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown OrganizationPerson edge %s", name)
}

// PersonMutation represents an operation that mutates the Person nodes in the graph.
type PersonMutation struct {
	config
	op                      Op
	typ                     string
	id                      *int
	date_created            *time.Time
	date_updated            *time.Time
	public_id               *string
	identifier              *[]string
	appendidentifier        []string
	identifier_values       *[]string
	appendidentifier_values []string
	active                  *bool
	birth_date              *string
	email                   *string
	given_name              *string
	name                    *string
	family_name             *string
	job_category            *[]string
	appendjob_category      []string
	preferred_given_name    *string
	preferred_family_name   *string
	honorific_prefix        *string
	role                    *[]string
	appendrole              []string
	settings                *map[string]string
	object_class            *[]string
	appendobject_class      []string
	expiration_date         *string
	token                   *[]string
	appendtoken             []string
	clearedFields           map[string]struct{}
	done                    bool
	oldValue                func(context.Context) (*Person, error)
	predicates              []predicate.Person
}

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

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

// newPersonMutation creates new mutation for the Person entity.
func newPersonMutation(c config, op Op, opts ...personOption) *PersonMutation {
	m := &PersonMutation{
		config:        c,
		op:            op,
		typ:           TypePerson,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *PersonMutation) 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 *PersonMutation) 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().Person.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetDateCreated sets the "date_created" field.
func (m *PersonMutation) SetDateCreated(t time.Time) {
	m.date_created = &t
}

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

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

// ResetDateCreated resets all changes to the "date_created" field.
func (m *PersonMutation) ResetDateCreated() {
	m.date_created = nil
}

// SetDateUpdated sets the "date_updated" field.
func (m *PersonMutation) SetDateUpdated(t time.Time) {
	m.date_updated = &t
}

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

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

// ResetDateUpdated resets all changes to the "date_updated" field.
func (m *PersonMutation) ResetDateUpdated() {
	m.date_updated = nil
}

// SetPublicID sets the "public_id" field.
func (m *PersonMutation) SetPublicID(s string) {
	m.public_id = &s
}

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

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

// ResetPublicID resets all changes to the "public_id" field.
func (m *PersonMutation) ResetPublicID() {
	m.public_id = nil
}

// SetIdentifier sets the "identifier" field.
func (m *PersonMutation) SetIdentifier(s []string) {
	m.identifier = &s
	m.appendidentifier = nil
}

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

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

// AppendIdentifier adds s to the "identifier" field.
func (m *PersonMutation) AppendIdentifier(s []string) {
	m.appendidentifier = append(m.appendidentifier, s...)
}

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

// ClearIdentifier clears the value of the "identifier" field.
func (m *PersonMutation) ClearIdentifier() {
	m.identifier = nil
	m.appendidentifier = nil
	m.clearedFields[person.FieldIdentifier] = struct{}{}
}

// IdentifierCleared returns if the "identifier" field was cleared in this mutation.
func (m *PersonMutation) IdentifierCleared() bool {
	_, ok := m.clearedFields[person.FieldIdentifier]
	return ok
}

// ResetIdentifier resets all changes to the "identifier" field.
func (m *PersonMutation) ResetIdentifier() {
	m.identifier = nil
	m.appendidentifier = nil
	delete(m.clearedFields, person.FieldIdentifier)
}

// SetIdentifierValues sets the "identifier_values" field.
func (m *PersonMutation) SetIdentifierValues(s []string) {
	m.identifier_values = &s
	m.appendidentifier_values = nil
}

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

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

// AppendIdentifierValues adds s to the "identifier_values" field.
func (m *PersonMutation) AppendIdentifierValues(s []string) {
	m.appendidentifier_values = append(m.appendidentifier_values, s...)
}

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

// ClearIdentifierValues clears the value of the "identifier_values" field.
func (m *PersonMutation) ClearIdentifierValues() {
	m.identifier_values = nil
	m.appendidentifier_values = nil
	m.clearedFields[person.FieldIdentifierValues] = struct{}{}
}

// IdentifierValuesCleared returns if the "identifier_values" field was cleared in this mutation.
func (m *PersonMutation) IdentifierValuesCleared() bool {
	_, ok := m.clearedFields[person.FieldIdentifierValues]
	return ok
}

// ResetIdentifierValues resets all changes to the "identifier_values" field.
func (m *PersonMutation) ResetIdentifierValues() {
	m.identifier_values = nil
	m.appendidentifier_values = nil
	delete(m.clearedFields, person.FieldIdentifierValues)
}

// SetActive sets the "active" field.
func (m *PersonMutation) SetActive(b bool) {
	m.active = &b
}

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

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

// ResetActive resets all changes to the "active" field.
func (m *PersonMutation) ResetActive() {
	m.active = nil
}

// SetBirthDate sets the "birth_date" field.
func (m *PersonMutation) SetBirthDate(s string) {
	m.birth_date = &s
}

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

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

// ClearBirthDate clears the value of the "birth_date" field.
func (m *PersonMutation) ClearBirthDate() {
	m.birth_date = nil
	m.clearedFields[person.FieldBirthDate] = struct{}{}
}

// BirthDateCleared returns if the "birth_date" field was cleared in this mutation.
func (m *PersonMutation) BirthDateCleared() bool {
	_, ok := m.clearedFields[person.FieldBirthDate]
	return ok
}

// ResetBirthDate resets all changes to the "birth_date" field.
func (m *PersonMutation) ResetBirthDate() {
	m.birth_date = nil
	delete(m.clearedFields, person.FieldBirthDate)
}

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

// Email returns the value of the "email" field in the mutation.
func (m *PersonMutation) 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 Person entity.
// If the Person 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 *PersonMutation) 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
}

// ClearEmail clears the value of the "email" field.
func (m *PersonMutation) ClearEmail() {
	m.email = nil
	m.clearedFields[person.FieldEmail] = struct{}{}
}

// EmailCleared returns if the "email" field was cleared in this mutation.
func (m *PersonMutation) EmailCleared() bool {
	_, ok := m.clearedFields[person.FieldEmail]
	return ok
}

// ResetEmail resets all changes to the "email" field.
func (m *PersonMutation) ResetEmail() {
	m.email = nil
	delete(m.clearedFields, person.FieldEmail)
}

// SetGivenName sets the "given_name" field.
func (m *PersonMutation) SetGivenName(s string) {
	m.given_name = &s
}

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

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

// ClearGivenName clears the value of the "given_name" field.
func (m *PersonMutation) ClearGivenName() {
	m.given_name = nil
	m.clearedFields[person.FieldGivenName] = struct{}{}
}

// GivenNameCleared returns if the "given_name" field was cleared in this mutation.
func (m *PersonMutation) GivenNameCleared() bool {
	_, ok := m.clearedFields[person.FieldGivenName]
	return ok
}

// ResetGivenName resets all changes to the "given_name" field.
func (m *PersonMutation) ResetGivenName() {
	m.given_name = nil
	delete(m.clearedFields, person.FieldGivenName)
}

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

// Name returns the value of the "name" field in the mutation.
func (m *PersonMutation) 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 Person entity.
// If the Person 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 *PersonMutation) 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
}

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

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

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

// SetFamilyName sets the "family_name" field.
func (m *PersonMutation) SetFamilyName(s string) {
	m.family_name = &s
}

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

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

// ClearFamilyName clears the value of the "family_name" field.
func (m *PersonMutation) ClearFamilyName() {
	m.family_name = nil
	m.clearedFields[person.FieldFamilyName] = struct{}{}
}

// FamilyNameCleared returns if the "family_name" field was cleared in this mutation.
func (m *PersonMutation) FamilyNameCleared() bool {
	_, ok := m.clearedFields[person.FieldFamilyName]
	return ok
}

// ResetFamilyName resets all changes to the "family_name" field.
func (m *PersonMutation) ResetFamilyName() {
	m.family_name = nil
	delete(m.clearedFields, person.FieldFamilyName)
}

// SetJobCategory sets the "job_category" field.
func (m *PersonMutation) SetJobCategory(s []string) {
	m.job_category = &s
	m.appendjob_category = nil
}

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

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

// AppendJobCategory adds s to the "job_category" field.
func (m *PersonMutation) AppendJobCategory(s []string) {
	m.appendjob_category = append(m.appendjob_category, s...)
}

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

// ClearJobCategory clears the value of the "job_category" field.
func (m *PersonMutation) ClearJobCategory() {
	m.job_category = nil
	m.appendjob_category = nil
	m.clearedFields[person.FieldJobCategory] = struct{}{}
}

// JobCategoryCleared returns if the "job_category" field was cleared in this mutation.
func (m *PersonMutation) JobCategoryCleared() bool {
	_, ok := m.clearedFields[person.FieldJobCategory]
	return ok
}

// ResetJobCategory resets all changes to the "job_category" field.
func (m *PersonMutation) ResetJobCategory() {
	m.job_category = nil
	m.appendjob_category = nil
	delete(m.clearedFields, person.FieldJobCategory)
}

// SetPreferredGivenName sets the "preferred_given_name" field.
func (m *PersonMutation) SetPreferredGivenName(s string) {
	m.preferred_given_name = &s
}

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

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

// ClearPreferredGivenName clears the value of the "preferred_given_name" field.
func (m *PersonMutation) ClearPreferredGivenName() {
	m.preferred_given_name = nil
	m.clearedFields[person.FieldPreferredGivenName] = struct{}{}
}

// PreferredGivenNameCleared returns if the "preferred_given_name" field was cleared in this mutation.
func (m *PersonMutation) PreferredGivenNameCleared() bool {
	_, ok := m.clearedFields[person.FieldPreferredGivenName]
	return ok
}

// ResetPreferredGivenName resets all changes to the "preferred_given_name" field.
func (m *PersonMutation) ResetPreferredGivenName() {
	m.preferred_given_name = nil
	delete(m.clearedFields, person.FieldPreferredGivenName)
}

// SetPreferredFamilyName sets the "preferred_family_name" field.
func (m *PersonMutation) SetPreferredFamilyName(s string) {
	m.preferred_family_name = &s
}

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

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

// ClearPreferredFamilyName clears the value of the "preferred_family_name" field.
func (m *PersonMutation) ClearPreferredFamilyName() {
	m.preferred_family_name = nil
	m.clearedFields[person.FieldPreferredFamilyName] = struct{}{}
}

// PreferredFamilyNameCleared returns if the "preferred_family_name" field was cleared in this mutation.
func (m *PersonMutation) PreferredFamilyNameCleared() bool {
	_, ok := m.clearedFields[person.FieldPreferredFamilyName]
	return ok
}

// ResetPreferredFamilyName resets all changes to the "preferred_family_name" field.
func (m *PersonMutation) ResetPreferredFamilyName() {
	m.preferred_family_name = nil
	delete(m.clearedFields, person.FieldPreferredFamilyName)
}

// SetHonorificPrefix sets the "honorific_prefix" field.
func (m *PersonMutation) SetHonorificPrefix(s string) {
	m.honorific_prefix = &s
}

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

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

// ClearHonorificPrefix clears the value of the "honorific_prefix" field.
func (m *PersonMutation) ClearHonorificPrefix() {
	m.honorific_prefix = nil
	m.clearedFields[person.FieldHonorificPrefix] = struct{}{}
}

// HonorificPrefixCleared returns if the "honorific_prefix" field was cleared in this mutation.
func (m *PersonMutation) HonorificPrefixCleared() bool {
	_, ok := m.clearedFields[person.FieldHonorificPrefix]
	return ok
}

// ResetHonorificPrefix resets all changes to the "honorific_prefix" field.
func (m *PersonMutation) ResetHonorificPrefix() {
	m.honorific_prefix = nil
	delete(m.clearedFields, person.FieldHonorificPrefix)
}

// SetRole sets the "role" field.
func (m *PersonMutation) SetRole(s []string) {
	m.role = &s
	m.appendrole = nil
}

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

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

// AppendRole adds s to the "role" field.
func (m *PersonMutation) AppendRole(s []string) {
	m.appendrole = append(m.appendrole, s...)
}

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

// ClearRole clears the value of the "role" field.
func (m *PersonMutation) ClearRole() {
	m.role = nil
	m.appendrole = nil
	m.clearedFields[person.FieldRole] = struct{}{}
}

// RoleCleared returns if the "role" field was cleared in this mutation.
func (m *PersonMutation) RoleCleared() bool {
	_, ok := m.clearedFields[person.FieldRole]
	return ok
}

// ResetRole resets all changes to the "role" field.
func (m *PersonMutation) ResetRole() {
	m.role = nil
	m.appendrole = nil
	delete(m.clearedFields, person.FieldRole)
}

// SetSettings sets the "settings" field.
func (m *PersonMutation) SetSettings(value map[string]string) {
	m.settings = &value
}

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

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

// ClearSettings clears the value of the "settings" field.
func (m *PersonMutation) ClearSettings() {
	m.settings = nil
	m.clearedFields[person.FieldSettings] = struct{}{}
}

// SettingsCleared returns if the "settings" field was cleared in this mutation.
func (m *PersonMutation) SettingsCleared() bool {
	_, ok := m.clearedFields[person.FieldSettings]
	return ok
}

// ResetSettings resets all changes to the "settings" field.
func (m *PersonMutation) ResetSettings() {
	m.settings = nil
	delete(m.clearedFields, person.FieldSettings)
}

// SetObjectClass sets the "object_class" field.
func (m *PersonMutation) SetObjectClass(s []string) {
	m.object_class = &s
	m.appendobject_class = nil
}

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

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

// AppendObjectClass adds s to the "object_class" field.
func (m *PersonMutation) AppendObjectClass(s []string) {
	m.appendobject_class = append(m.appendobject_class, s...)
}

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

// ClearObjectClass clears the value of the "object_class" field.
func (m *PersonMutation) ClearObjectClass() {
	m.object_class = nil
	m.appendobject_class = nil
	m.clearedFields[person.FieldObjectClass] = struct{}{}
}

// ObjectClassCleared returns if the "object_class" field was cleared in this mutation.
func (m *PersonMutation) ObjectClassCleared() bool {
	_, ok := m.clearedFields[person.FieldObjectClass]
	return ok
}

// ResetObjectClass resets all changes to the "object_class" field.
func (m *PersonMutation) ResetObjectClass() {
	m.object_class = nil
	m.appendobject_class = nil
	delete(m.clearedFields, person.FieldObjectClass)
}

// SetExpirationDate sets the "expiration_date" field.
func (m *PersonMutation) SetExpirationDate(s string) {
	m.expiration_date = &s
}

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

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

// ClearExpirationDate clears the value of the "expiration_date" field.
func (m *PersonMutation) ClearExpirationDate() {
	m.expiration_date = nil
	m.clearedFields[person.FieldExpirationDate] = struct{}{}
}

// ExpirationDateCleared returns if the "expiration_date" field was cleared in this mutation.
func (m *PersonMutation) ExpirationDateCleared() bool {
	_, ok := m.clearedFields[person.FieldExpirationDate]
	return ok
}

// ResetExpirationDate resets all changes to the "expiration_date" field.
func (m *PersonMutation) ResetExpirationDate() {
	m.expiration_date = nil
	delete(m.clearedFields, person.FieldExpirationDate)
}

// SetToken sets the "token" field.
func (m *PersonMutation) SetToken(s []string) {
	m.token = &s
	m.appendtoken = nil
}

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

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

// AppendToken adds s to the "token" field.
func (m *PersonMutation) AppendToken(s []string) {
	m.appendtoken = append(m.appendtoken, s...)
}

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

// ClearToken clears the value of the "token" field.
func (m *PersonMutation) ClearToken() {
	m.token = nil
	m.appendtoken = nil
	m.clearedFields[person.FieldToken] = struct{}{}
}

// TokenCleared returns if the "token" field was cleared in this mutation.
func (m *PersonMutation) TokenCleared() bool {
	_, ok := m.clearedFields[person.FieldToken]
	return ok
}

// ResetToken resets all changes to the "token" field.
func (m *PersonMutation) ResetToken() {
	m.token = nil
	m.appendtoken = nil
	delete(m.clearedFields, person.FieldToken)
}

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

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

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

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

// Type returns the node type of this mutation (Person).
func (m *PersonMutation) 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 *PersonMutation) Fields() []string {
	fields := make([]string, 0, 20)
	if m.date_created != nil {
		fields = append(fields, person.FieldDateCreated)
	}
	if m.date_updated != nil {
		fields = append(fields, person.FieldDateUpdated)
	}
	if m.public_id != nil {
		fields = append(fields, person.FieldPublicID)
	}
	if m.identifier != nil {
		fields = append(fields, person.FieldIdentifier)
	}
	if m.identifier_values != nil {
		fields = append(fields, person.FieldIdentifierValues)
	}
	if m.active != nil {
		fields = append(fields, person.FieldActive)
	}
	if m.birth_date != nil {
		fields = append(fields, person.FieldBirthDate)
	}
	if m.email != nil {
		fields = append(fields, person.FieldEmail)
	}
	if m.given_name != nil {
		fields = append(fields, person.FieldGivenName)
	}
	if m.name != nil {
		fields = append(fields, person.FieldName)
	}
	if m.family_name != nil {
		fields = append(fields, person.FieldFamilyName)
	}
	if m.job_category != nil {
		fields = append(fields, person.FieldJobCategory)
	}
	if m.preferred_given_name != nil {
		fields = append(fields, person.FieldPreferredGivenName)
	}
	if m.preferred_family_name != nil {
		fields = append(fields, person.FieldPreferredFamilyName)
	}
	if m.honorific_prefix != nil {
		fields = append(fields, person.FieldHonorificPrefix)
	}
	if m.role != nil {
		fields = append(fields, person.FieldRole)
	}
	if m.settings != nil {
		fields = append(fields, person.FieldSettings)
	}
	if m.object_class != nil {
		fields = append(fields, person.FieldObjectClass)
	}
	if m.expiration_date != nil {
		fields = append(fields, person.FieldExpirationDate)
	}
	if m.token != nil {
		fields = append(fields, person.FieldToken)
	}
	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 *PersonMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case person.FieldDateCreated:
		return m.DateCreated()
	case person.FieldDateUpdated:
		return m.DateUpdated()
	case person.FieldPublicID:
		return m.PublicID()
	case person.FieldIdentifier:
		return m.Identifier()
	case person.FieldIdentifierValues:
		return m.IdentifierValues()
	case person.FieldActive:
		return m.Active()
	case person.FieldBirthDate:
		return m.BirthDate()
	case person.FieldEmail:
		return m.Email()
	case person.FieldGivenName:
		return m.GivenName()
	case person.FieldName:
		return m.Name()
	case person.FieldFamilyName:
		return m.FamilyName()
	case person.FieldJobCategory:
		return m.JobCategory()
	case person.FieldPreferredGivenName:
		return m.PreferredGivenName()
	case person.FieldPreferredFamilyName:
		return m.PreferredFamilyName()
	case person.FieldHonorificPrefix:
		return m.HonorificPrefix()
	case person.FieldRole:
		return m.Role()
	case person.FieldSettings:
		return m.Settings()
	case person.FieldObjectClass:
		return m.ObjectClass()
	case person.FieldExpirationDate:
		return m.ExpirationDate()
	case person.FieldToken:
		return m.Token()
	}
	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 *PersonMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case person.FieldDateCreated:
		return m.OldDateCreated(ctx)
	case person.FieldDateUpdated:
		return m.OldDateUpdated(ctx)
	case person.FieldPublicID:
		return m.OldPublicID(ctx)
	case person.FieldIdentifier:
		return m.OldIdentifier(ctx)
	case person.FieldIdentifierValues:
		return m.OldIdentifierValues(ctx)
	case person.FieldActive:
		return m.OldActive(ctx)
	case person.FieldBirthDate:
		return m.OldBirthDate(ctx)
	case person.FieldEmail:
		return m.OldEmail(ctx)
	case person.FieldGivenName:
		return m.OldGivenName(ctx)
	case person.FieldName:
		return m.OldName(ctx)
	case person.FieldFamilyName:
		return m.OldFamilyName(ctx)
	case person.FieldJobCategory:
		return m.OldJobCategory(ctx)
	case person.FieldPreferredGivenName:
		return m.OldPreferredGivenName(ctx)
	case person.FieldPreferredFamilyName:
		return m.OldPreferredFamilyName(ctx)
	case person.FieldHonorificPrefix:
		return m.OldHonorificPrefix(ctx)
	case person.FieldRole:
		return m.OldRole(ctx)
	case person.FieldSettings:
		return m.OldSettings(ctx)
	case person.FieldObjectClass:
		return m.OldObjectClass(ctx)
	case person.FieldExpirationDate:
		return m.OldExpirationDate(ctx)
	case person.FieldToken:
		return m.OldToken(ctx)
	}
	return nil, fmt.Errorf("unknown Person 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 *PersonMutation) SetField(name string, value ent.Value) error {
	switch name {
	case person.FieldDateCreated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateCreated(v)
		return nil
	case person.FieldDateUpdated:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateUpdated(v)
		return nil
	case person.FieldPublicID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPublicID(v)
		return nil
	case person.FieldIdentifier:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIdentifier(v)
		return nil
	case person.FieldIdentifierValues:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIdentifierValues(v)
		return nil
	case person.FieldActive:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActive(v)
		return nil
	case person.FieldBirthDate:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBirthDate(v)
		return nil
	case person.FieldEmail:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmail(v)
		return nil
	case person.FieldGivenName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGivenName(v)
		return nil
	case person.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case person.FieldFamilyName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFamilyName(v)
		return nil
	case person.FieldJobCategory:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetJobCategory(v)
		return nil
	case person.FieldPreferredGivenName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPreferredGivenName(v)
		return nil
	case person.FieldPreferredFamilyName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPreferredFamilyName(v)
		return nil
	case person.FieldHonorificPrefix:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHonorificPrefix(v)
		return nil
	case person.FieldRole:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRole(v)
		return nil
	case person.FieldSettings:
		v, ok := value.(map[string]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSettings(v)
		return nil
	case person.FieldObjectClass:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetObjectClass(v)
		return nil
	case person.FieldExpirationDate:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExpirationDate(v)
		return nil
	case person.FieldToken:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToken(v)
		return nil
	}
	return fmt.Errorf("unknown Person field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *PersonMutation) 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 *PersonMutation) 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 *PersonMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Person numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *PersonMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(person.FieldIdentifier) {
		fields = append(fields, person.FieldIdentifier)
	}
	if m.FieldCleared(person.FieldIdentifierValues) {
		fields = append(fields, person.FieldIdentifierValues)
	}
	if m.FieldCleared(person.FieldBirthDate) {
		fields = append(fields, person.FieldBirthDate)
	}
	if m.FieldCleared(person.FieldEmail) {
		fields = append(fields, person.FieldEmail)
	}
	if m.FieldCleared(person.FieldGivenName) {
		fields = append(fields, person.FieldGivenName)
	}
	if m.FieldCleared(person.FieldName) {
		fields = append(fields, person.FieldName)
	}
	if m.FieldCleared(person.FieldFamilyName) {
		fields = append(fields, person.FieldFamilyName)
	}
	if m.FieldCleared(person.FieldJobCategory) {
		fields = append(fields, person.FieldJobCategory)
	}
	if m.FieldCleared(person.FieldPreferredGivenName) {
		fields = append(fields, person.FieldPreferredGivenName)
	}
	if m.FieldCleared(person.FieldPreferredFamilyName) {
		fields = append(fields, person.FieldPreferredFamilyName)
	}
	if m.FieldCleared(person.FieldHonorificPrefix) {
		fields = append(fields, person.FieldHonorificPrefix)
	}
	if m.FieldCleared(person.FieldRole) {
		fields = append(fields, person.FieldRole)
	}
	if m.FieldCleared(person.FieldSettings) {
		fields = append(fields, person.FieldSettings)
	}
	if m.FieldCleared(person.FieldObjectClass) {
		fields = append(fields, person.FieldObjectClass)
	}
	if m.FieldCleared(person.FieldExpirationDate) {
		fields = append(fields, person.FieldExpirationDate)
	}
	if m.FieldCleared(person.FieldToken) {
		fields = append(fields, person.FieldToken)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PersonMutation) 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 *PersonMutation) ClearField(name string) error {
	switch name {
	case person.FieldIdentifier:
		m.ClearIdentifier()
		return nil
	case person.FieldIdentifierValues:
		m.ClearIdentifierValues()
		return nil
	case person.FieldBirthDate:
		m.ClearBirthDate()
		return nil
	case person.FieldEmail:
		m.ClearEmail()
		return nil
	case person.FieldGivenName:
		m.ClearGivenName()
		return nil
	case person.FieldName:
		m.ClearName()
		return nil
	case person.FieldFamilyName:
		m.ClearFamilyName()
		return nil
	case person.FieldJobCategory:
		m.ClearJobCategory()
		return nil
	case person.FieldPreferredGivenName:
		m.ClearPreferredGivenName()
		return nil
	case person.FieldPreferredFamilyName:
		m.ClearPreferredFamilyName()
		return nil
	case person.FieldHonorificPrefix:
		m.ClearHonorificPrefix()
		return nil
	case person.FieldRole:
		m.ClearRole()
		return nil
	case person.FieldSettings:
		m.ClearSettings()
		return nil
	case person.FieldObjectClass:
		m.ClearObjectClass()
		return nil
	case person.FieldExpirationDate:
		m.ClearExpirationDate()
		return nil
	case person.FieldToken:
		m.ClearToken()
		return nil
	}
	return fmt.Errorf("unknown Person 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 *PersonMutation) ResetField(name string) error {
	switch name {
	case person.FieldDateCreated:
		m.ResetDateCreated()
		return nil
	case person.FieldDateUpdated:
		m.ResetDateUpdated()
		return nil
	case person.FieldPublicID:
		m.ResetPublicID()
		return nil
	case person.FieldIdentifier:
		m.ResetIdentifier()
		return nil
	case person.FieldIdentifierValues:
		m.ResetIdentifierValues()
		return nil
	case person.FieldActive:
		m.ResetActive()
		return nil
	case person.FieldBirthDate:
		m.ResetBirthDate()
		return nil
	case person.FieldEmail:
		m.ResetEmail()
		return nil
	case person.FieldGivenName:
		m.ResetGivenName()
		return nil
	case person.FieldName:
		m.ResetName()
		return nil
	case person.FieldFamilyName:
		m.ResetFamilyName()
		return nil
	case person.FieldJobCategory:
		m.ResetJobCategory()
		return nil
	case person.FieldPreferredGivenName:
		m.ResetPreferredGivenName()
		return nil
	case person.FieldPreferredFamilyName:
		m.ResetPreferredFamilyName()
		return nil
	case person.FieldHonorificPrefix:
		m.ResetHonorificPrefix()
		return nil
	case person.FieldRole:
		m.ResetRole()
		return nil
	case person.FieldSettings:
		m.ResetSettings()
		return nil
	case person.FieldObjectClass:
		m.ResetObjectClass()
		return nil
	case person.FieldExpirationDate:
		m.ResetExpirationDate()
		return nil
	case person.FieldToken:
		m.ResetToken()
		return nil
	}
	return fmt.Errorf("unknown Person field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *PersonMutation) 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 *PersonMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *PersonMutation) 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 *PersonMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PersonMutation) 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 *PersonMutation) 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 *PersonMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Person 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 *PersonMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Person edge %s", name)
}