// Code generated by ent, DO NOT EDIT.

package ent

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

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/categorie"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/champpersonnalise"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/emplacement"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/lienobjetemplacement"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/objet"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/piecejointe"
	"gitea.maison43.duckdns.org/gilles/matosbox/internal/data/ent/predicate"
	"github.com/google/uuid"
)

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

	// Node types.
	TypeCategorie            = "Categorie"
	TypeChampPersonnalise    = "ChampPersonnalise"
	TypeEmplacement          = "Emplacement"
	TypeLienObjetEmplacement = "LienObjetEmplacement"
	TypeObjet                = "Objet"
	TypePieceJointe          = "PieceJointe"
)

// CategorieMutation represents an operation that mutates the Categorie nodes in the graph.
type CategorieMutation struct {
	config
	op             Op
	typ            string
	id             *uuid.UUID
	nom            *string
	slug           *string
	icone          *string
	created_at     *time.Time
	updated_at     *time.Time
	clearedFields  map[string]struct{}
	parent         *uuid.UUID
	clearedparent  bool
	enfants        map[uuid.UUID]struct{}
	removedenfants map[uuid.UUID]struct{}
	clearedenfants bool
	done           bool
	oldValue       func(context.Context) (*Categorie, error)
	predicates     []predicate.Categorie
}

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

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

// newCategorieMutation creates new mutation for the Categorie entity.
func newCategorieMutation(c config, op Op, opts ...categorieOption) *CategorieMutation {
	m := &CategorieMutation{
		config:        c,
		op:            op,
		typ:           TypeCategorie,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetNom sets the "nom" field.
func (m *CategorieMutation) SetNom(s string) {
	m.nom = &s
}

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

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

// ResetNom resets all changes to the "nom" field.
func (m *CategorieMutation) ResetNom() {
	m.nom = nil
}

// SetParentID sets the "parent_id" field.
func (m *CategorieMutation) SetParentID(u uuid.UUID) {
	m.parent = &u
}

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

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

// ClearParentID clears the value of the "parent_id" field.
func (m *CategorieMutation) ClearParentID() {
	m.parent = nil
	m.clearedFields[categorie.FieldParentID] = struct{}{}
}

// ParentIDCleared returns if the "parent_id" field was cleared in this mutation.
func (m *CategorieMutation) ParentIDCleared() bool {
	_, ok := m.clearedFields[categorie.FieldParentID]
	return ok
}

// ResetParentID resets all changes to the "parent_id" field.
func (m *CategorieMutation) ResetParentID() {
	m.parent = nil
	delete(m.clearedFields, categorie.FieldParentID)
}

// SetSlug sets the "slug" field.
func (m *CategorieMutation) SetSlug(s string) {
	m.slug = &s
}

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

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

// ClearSlug clears the value of the "slug" field.
func (m *CategorieMutation) ClearSlug() {
	m.slug = nil
	m.clearedFields[categorie.FieldSlug] = struct{}{}
}

// SlugCleared returns if the "slug" field was cleared in this mutation.
func (m *CategorieMutation) SlugCleared() bool {
	_, ok := m.clearedFields[categorie.FieldSlug]
	return ok
}

// ResetSlug resets all changes to the "slug" field.
func (m *CategorieMutation) ResetSlug() {
	m.slug = nil
	delete(m.clearedFields, categorie.FieldSlug)
}

// SetIcone sets the "icone" field.
func (m *CategorieMutation) SetIcone(s string) {
	m.icone = &s
}

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

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

// ClearIcone clears the value of the "icone" field.
func (m *CategorieMutation) ClearIcone() {
	m.icone = nil
	m.clearedFields[categorie.FieldIcone] = struct{}{}
}

// IconeCleared returns if the "icone" field was cleared in this mutation.
func (m *CategorieMutation) IconeCleared() bool {
	_, ok := m.clearedFields[categorie.FieldIcone]
	return ok
}

// ResetIcone resets all changes to the "icone" field.
func (m *CategorieMutation) ResetIcone() {
	m.icone = nil
	delete(m.clearedFields, categorie.FieldIcone)
}

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

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

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

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

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

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

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

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

// ClearParent clears the "parent" edge to the Categorie entity.
func (m *CategorieMutation) ClearParent() {
	m.clearedparent = true
	m.clearedFields[categorie.FieldParentID] = struct{}{}
}

// ParentCleared reports if the "parent" edge to the Categorie entity was cleared.
func (m *CategorieMutation) ParentCleared() bool {
	return m.ParentIDCleared() || m.clearedparent
}

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

// ResetParent resets all changes to the "parent" edge.
func (m *CategorieMutation) ResetParent() {
	m.parent = nil
	m.clearedparent = false
}

// AddEnfantIDs adds the "enfants" edge to the Categorie entity by ids.
func (m *CategorieMutation) AddEnfantIDs(ids ...uuid.UUID) {
	if m.enfants == nil {
		m.enfants = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.enfants[ids[i]] = struct{}{}
	}
}

// ClearEnfants clears the "enfants" edge to the Categorie entity.
func (m *CategorieMutation) ClearEnfants() {
	m.clearedenfants = true
}

// EnfantsCleared reports if the "enfants" edge to the Categorie entity was cleared.
func (m *CategorieMutation) EnfantsCleared() bool {
	return m.clearedenfants
}

// RemoveEnfantIDs removes the "enfants" edge to the Categorie entity by IDs.
func (m *CategorieMutation) RemoveEnfantIDs(ids ...uuid.UUID) {
	if m.removedenfants == nil {
		m.removedenfants = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.enfants, ids[i])
		m.removedenfants[ids[i]] = struct{}{}
	}
}

// RemovedEnfants returns the removed IDs of the "enfants" edge to the Categorie entity.
func (m *CategorieMutation) RemovedEnfantsIDs() (ids []uuid.UUID) {
	for id := range m.removedenfants {
		ids = append(ids, id)
	}
	return
}

// EnfantsIDs returns the "enfants" edge IDs in the mutation.
func (m *CategorieMutation) EnfantsIDs() (ids []uuid.UUID) {
	for id := range m.enfants {
		ids = append(ids, id)
	}
	return
}

// ResetEnfants resets all changes to the "enfants" edge.
func (m *CategorieMutation) ResetEnfants() {
	m.enfants = nil
	m.clearedenfants = false
	m.removedenfants = nil
}

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

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

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

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

// Type returns the node type of this mutation (Categorie).
func (m *CategorieMutation) 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 *CategorieMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.nom != nil {
		fields = append(fields, categorie.FieldNom)
	}
	if m.parent != nil {
		fields = append(fields, categorie.FieldParentID)
	}
	if m.slug != nil {
		fields = append(fields, categorie.FieldSlug)
	}
	if m.icone != nil {
		fields = append(fields, categorie.FieldIcone)
	}
	if m.created_at != nil {
		fields = append(fields, categorie.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, categorie.FieldUpdatedAt)
	}
	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 *CategorieMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case categorie.FieldNom:
		return m.Nom()
	case categorie.FieldParentID:
		return m.ParentID()
	case categorie.FieldSlug:
		return m.Slug()
	case categorie.FieldIcone:
		return m.Icone()
	case categorie.FieldCreatedAt:
		return m.CreatedAt()
	case categorie.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *CategorieMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case categorie.FieldNom:
		return m.OldNom(ctx)
	case categorie.FieldParentID:
		return m.OldParentID(ctx)
	case categorie.FieldSlug:
		return m.OldSlug(ctx)
	case categorie.FieldIcone:
		return m.OldIcone(ctx)
	case categorie.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case categorie.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Categorie 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 *CategorieMutation) SetField(name string, value ent.Value) error {
	switch name {
	case categorie.FieldNom:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNom(v)
		return nil
	case categorie.FieldParentID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetParentID(v)
		return nil
	case categorie.FieldSlug:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSlug(v)
		return nil
	case categorie.FieldIcone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIcone(v)
		return nil
	case categorie.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case categorie.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Categorie field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CategorieMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(categorie.FieldParentID) {
		fields = append(fields, categorie.FieldParentID)
	}
	if m.FieldCleared(categorie.FieldSlug) {
		fields = append(fields, categorie.FieldSlug)
	}
	if m.FieldCleared(categorie.FieldIcone) {
		fields = append(fields, categorie.FieldIcone)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CategorieMutation) 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 *CategorieMutation) ClearField(name string) error {
	switch name {
	case categorie.FieldParentID:
		m.ClearParentID()
		return nil
	case categorie.FieldSlug:
		m.ClearSlug()
		return nil
	case categorie.FieldIcone:
		m.ClearIcone()
		return nil
	}
	return fmt.Errorf("unknown Categorie 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 *CategorieMutation) ResetField(name string) error {
	switch name {
	case categorie.FieldNom:
		m.ResetNom()
		return nil
	case categorie.FieldParentID:
		m.ResetParentID()
		return nil
	case categorie.FieldSlug:
		m.ResetSlug()
		return nil
	case categorie.FieldIcone:
		m.ResetIcone()
		return nil
	case categorie.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case categorie.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown Categorie field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *CategorieMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.parent != nil {
		edges = append(edges, categorie.EdgeParent)
	}
	if m.enfants != nil {
		edges = append(edges, categorie.EdgeEnfants)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *CategorieMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedparent {
		edges = append(edges, categorie.EdgeParent)
	}
	if m.clearedenfants {
		edges = append(edges, categorie.EdgeEnfants)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *CategorieMutation) EdgeCleared(name string) bool {
	switch name {
	case categorie.EdgeParent:
		return m.clearedparent
	case categorie.EdgeEnfants:
		return m.clearedenfants
	}
	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 *CategorieMutation) ClearEdge(name string) error {
	switch name {
	case categorie.EdgeParent:
		m.ClearParent()
		return nil
	}
	return fmt.Errorf("unknown Categorie 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 *CategorieMutation) ResetEdge(name string) error {
	switch name {
	case categorie.EdgeParent:
		m.ResetParent()
		return nil
	case categorie.EdgeEnfants:
		m.ResetEnfants()
		return nil
	}
	return fmt.Errorf("unknown Categorie edge %s", name)
}

// ChampPersonnaliseMutation represents an operation that mutates the ChampPersonnalise nodes in the graph.
type ChampPersonnaliseMutation struct {
	config
	op            Op
	typ           string
	id            *uuid.UUID
	nom_champ     *string
	type_champ    *champpersonnalise.TypeChamp
	valeur        *string
	unite         *string
	created_at    *time.Time
	updated_at    *time.Time
	clearedFields map[string]struct{}
	objet         *uuid.UUID
	clearedobjet  bool
	done          bool
	oldValue      func(context.Context) (*ChampPersonnalise, error)
	predicates    []predicate.ChampPersonnalise
}

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

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

// newChampPersonnaliseMutation creates new mutation for the ChampPersonnalise entity.
func newChampPersonnaliseMutation(c config, op Op, opts ...champpersonnaliseOption) *ChampPersonnaliseMutation {
	m := &ChampPersonnaliseMutation{
		config:        c,
		op:            op,
		typ:           TypeChampPersonnalise,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetObjetID sets the "objet_id" field.
func (m *ChampPersonnaliseMutation) SetObjetID(u uuid.UUID) {
	m.objet = &u
}

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

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

// ResetObjetID resets all changes to the "objet_id" field.
func (m *ChampPersonnaliseMutation) ResetObjetID() {
	m.objet = nil
}

// SetNomChamp sets the "nom_champ" field.
func (m *ChampPersonnaliseMutation) SetNomChamp(s string) {
	m.nom_champ = &s
}

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

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

// ResetNomChamp resets all changes to the "nom_champ" field.
func (m *ChampPersonnaliseMutation) ResetNomChamp() {
	m.nom_champ = nil
}

// SetTypeChamp sets the "type_champ" field.
func (m *ChampPersonnaliseMutation) SetTypeChamp(cc champpersonnalise.TypeChamp) {
	m.type_champ = &cc
}

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

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

// ResetTypeChamp resets all changes to the "type_champ" field.
func (m *ChampPersonnaliseMutation) ResetTypeChamp() {
	m.type_champ = nil
}

// SetValeur sets the "valeur" field.
func (m *ChampPersonnaliseMutation) SetValeur(s string) {
	m.valeur = &s
}

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

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

// ClearValeur clears the value of the "valeur" field.
func (m *ChampPersonnaliseMutation) ClearValeur() {
	m.valeur = nil
	m.clearedFields[champpersonnalise.FieldValeur] = struct{}{}
}

// ValeurCleared returns if the "valeur" field was cleared in this mutation.
func (m *ChampPersonnaliseMutation) ValeurCleared() bool {
	_, ok := m.clearedFields[champpersonnalise.FieldValeur]
	return ok
}

// ResetValeur resets all changes to the "valeur" field.
func (m *ChampPersonnaliseMutation) ResetValeur() {
	m.valeur = nil
	delete(m.clearedFields, champpersonnalise.FieldValeur)
}

// SetUnite sets the "unite" field.
func (m *ChampPersonnaliseMutation) SetUnite(s string) {
	m.unite = &s
}

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

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

// ClearUnite clears the value of the "unite" field.
func (m *ChampPersonnaliseMutation) ClearUnite() {
	m.unite = nil
	m.clearedFields[champpersonnalise.FieldUnite] = struct{}{}
}

// UniteCleared returns if the "unite" field was cleared in this mutation.
func (m *ChampPersonnaliseMutation) UniteCleared() bool {
	_, ok := m.clearedFields[champpersonnalise.FieldUnite]
	return ok
}

// ResetUnite resets all changes to the "unite" field.
func (m *ChampPersonnaliseMutation) ResetUnite() {
	m.unite = nil
	delete(m.clearedFields, champpersonnalise.FieldUnite)
}

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

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

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

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

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

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

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

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

// ClearObjet clears the "objet" edge to the Objet entity.
func (m *ChampPersonnaliseMutation) ClearObjet() {
	m.clearedobjet = true
	m.clearedFields[champpersonnalise.FieldObjetID] = struct{}{}
}

// ObjetCleared reports if the "objet" edge to the Objet entity was cleared.
func (m *ChampPersonnaliseMutation) ObjetCleared() bool {
	return m.clearedobjet
}

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

// ResetObjet resets all changes to the "objet" edge.
func (m *ChampPersonnaliseMutation) ResetObjet() {
	m.objet = nil
	m.clearedobjet = false
}

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

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

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

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

// Type returns the node type of this mutation (ChampPersonnalise).
func (m *ChampPersonnaliseMutation) 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 *ChampPersonnaliseMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.objet != nil {
		fields = append(fields, champpersonnalise.FieldObjetID)
	}
	if m.nom_champ != nil {
		fields = append(fields, champpersonnalise.FieldNomChamp)
	}
	if m.type_champ != nil {
		fields = append(fields, champpersonnalise.FieldTypeChamp)
	}
	if m.valeur != nil {
		fields = append(fields, champpersonnalise.FieldValeur)
	}
	if m.unite != nil {
		fields = append(fields, champpersonnalise.FieldUnite)
	}
	if m.created_at != nil {
		fields = append(fields, champpersonnalise.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, champpersonnalise.FieldUpdatedAt)
	}
	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 *ChampPersonnaliseMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case champpersonnalise.FieldObjetID:
		return m.ObjetID()
	case champpersonnalise.FieldNomChamp:
		return m.NomChamp()
	case champpersonnalise.FieldTypeChamp:
		return m.TypeChamp()
	case champpersonnalise.FieldValeur:
		return m.Valeur()
	case champpersonnalise.FieldUnite:
		return m.Unite()
	case champpersonnalise.FieldCreatedAt:
		return m.CreatedAt()
	case champpersonnalise.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *ChampPersonnaliseMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case champpersonnalise.FieldObjetID:
		return m.OldObjetID(ctx)
	case champpersonnalise.FieldNomChamp:
		return m.OldNomChamp(ctx)
	case champpersonnalise.FieldTypeChamp:
		return m.OldTypeChamp(ctx)
	case champpersonnalise.FieldValeur:
		return m.OldValeur(ctx)
	case champpersonnalise.FieldUnite:
		return m.OldUnite(ctx)
	case champpersonnalise.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case champpersonnalise.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown ChampPersonnalise 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 *ChampPersonnaliseMutation) SetField(name string, value ent.Value) error {
	switch name {
	case champpersonnalise.FieldObjetID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetObjetID(v)
		return nil
	case champpersonnalise.FieldNomChamp:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNomChamp(v)
		return nil
	case champpersonnalise.FieldTypeChamp:
		v, ok := value.(champpersonnalise.TypeChamp)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTypeChamp(v)
		return nil
	case champpersonnalise.FieldValeur:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetValeur(v)
		return nil
	case champpersonnalise.FieldUnite:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUnite(v)
		return nil
	case champpersonnalise.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case champpersonnalise.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown ChampPersonnalise field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ChampPersonnaliseMutation) 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 *ChampPersonnaliseMutation) ClearField(name string) error {
	switch name {
	case champpersonnalise.FieldValeur:
		m.ClearValeur()
		return nil
	case champpersonnalise.FieldUnite:
		m.ClearUnite()
		return nil
	}
	return fmt.Errorf("unknown ChampPersonnalise 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 *ChampPersonnaliseMutation) ResetField(name string) error {
	switch name {
	case champpersonnalise.FieldObjetID:
		m.ResetObjetID()
		return nil
	case champpersonnalise.FieldNomChamp:
		m.ResetNomChamp()
		return nil
	case champpersonnalise.FieldTypeChamp:
		m.ResetTypeChamp()
		return nil
	case champpersonnalise.FieldValeur:
		m.ResetValeur()
		return nil
	case champpersonnalise.FieldUnite:
		m.ResetUnite()
		return nil
	case champpersonnalise.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case champpersonnalise.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown ChampPersonnalise field %s", name)
}

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

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ChampPersonnaliseMutation) EdgeCleared(name string) bool {
	switch name {
	case champpersonnalise.EdgeObjet:
		return m.clearedobjet
	}
	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 *ChampPersonnaliseMutation) ClearEdge(name string) error {
	switch name {
	case champpersonnalise.EdgeObjet:
		m.ClearObjet()
		return nil
	}
	return fmt.Errorf("unknown ChampPersonnalise 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 *ChampPersonnaliseMutation) ResetEdge(name string) error {
	switch name {
	case champpersonnalise.EdgeObjet:
		m.ResetObjet()
		return nil
	}
	return fmt.Errorf("unknown ChampPersonnalise edge %s", name)
}

// EmplacementMutation represents an operation that mutates the Emplacement nodes in the graph.
type EmplacementMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	nom                 *string
	slug                *string
	piece               *string
	meuble              *string
	numero_boite        *string
	icone               *string
	created_at          *time.Time
	updated_at          *time.Time
	clearedFields       map[string]struct{}
	parent              *uuid.UUID
	clearedparent       bool
	enfants             map[uuid.UUID]struct{}
	removedenfants      map[uuid.UUID]struct{}
	clearedenfants      bool
	liens_objets        map[uuid.UUID]struct{}
	removedliens_objets map[uuid.UUID]struct{}
	clearedliens_objets bool
	done                bool
	oldValue            func(context.Context) (*Emplacement, error)
	predicates          []predicate.Emplacement
}

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

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

// newEmplacementMutation creates new mutation for the Emplacement entity.
func newEmplacementMutation(c config, op Op, opts ...emplacementOption) *EmplacementMutation {
	m := &EmplacementMutation{
		config:        c,
		op:            op,
		typ:           TypeEmplacement,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetNom sets the "nom" field.
func (m *EmplacementMutation) SetNom(s string) {
	m.nom = &s
}

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

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

// ResetNom resets all changes to the "nom" field.
func (m *EmplacementMutation) ResetNom() {
	m.nom = nil
}

// SetParentID sets the "parent_id" field.
func (m *EmplacementMutation) SetParentID(u uuid.UUID) {
	m.parent = &u
}

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

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

// ClearParentID clears the value of the "parent_id" field.
func (m *EmplacementMutation) ClearParentID() {
	m.parent = nil
	m.clearedFields[emplacement.FieldParentID] = struct{}{}
}

// ParentIDCleared returns if the "parent_id" field was cleared in this mutation.
func (m *EmplacementMutation) ParentIDCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldParentID]
	return ok
}

// ResetParentID resets all changes to the "parent_id" field.
func (m *EmplacementMutation) ResetParentID() {
	m.parent = nil
	delete(m.clearedFields, emplacement.FieldParentID)
}

// SetSlug sets the "slug" field.
func (m *EmplacementMutation) SetSlug(s string) {
	m.slug = &s
}

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

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

// ClearSlug clears the value of the "slug" field.
func (m *EmplacementMutation) ClearSlug() {
	m.slug = nil
	m.clearedFields[emplacement.FieldSlug] = struct{}{}
}

// SlugCleared returns if the "slug" field was cleared in this mutation.
func (m *EmplacementMutation) SlugCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldSlug]
	return ok
}

// ResetSlug resets all changes to the "slug" field.
func (m *EmplacementMutation) ResetSlug() {
	m.slug = nil
	delete(m.clearedFields, emplacement.FieldSlug)
}

// SetPiece sets the "piece" field.
func (m *EmplacementMutation) SetPiece(s string) {
	m.piece = &s
}

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

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

// ClearPiece clears the value of the "piece" field.
func (m *EmplacementMutation) ClearPiece() {
	m.piece = nil
	m.clearedFields[emplacement.FieldPiece] = struct{}{}
}

// PieceCleared returns if the "piece" field was cleared in this mutation.
func (m *EmplacementMutation) PieceCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldPiece]
	return ok
}

// ResetPiece resets all changes to the "piece" field.
func (m *EmplacementMutation) ResetPiece() {
	m.piece = nil
	delete(m.clearedFields, emplacement.FieldPiece)
}

// SetMeuble sets the "meuble" field.
func (m *EmplacementMutation) SetMeuble(s string) {
	m.meuble = &s
}

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

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

// ClearMeuble clears the value of the "meuble" field.
func (m *EmplacementMutation) ClearMeuble() {
	m.meuble = nil
	m.clearedFields[emplacement.FieldMeuble] = struct{}{}
}

// MeubleCleared returns if the "meuble" field was cleared in this mutation.
func (m *EmplacementMutation) MeubleCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldMeuble]
	return ok
}

// ResetMeuble resets all changes to the "meuble" field.
func (m *EmplacementMutation) ResetMeuble() {
	m.meuble = nil
	delete(m.clearedFields, emplacement.FieldMeuble)
}

// SetNumeroBoite sets the "numero_boite" field.
func (m *EmplacementMutation) SetNumeroBoite(s string) {
	m.numero_boite = &s
}

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

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

// ClearNumeroBoite clears the value of the "numero_boite" field.
func (m *EmplacementMutation) ClearNumeroBoite() {
	m.numero_boite = nil
	m.clearedFields[emplacement.FieldNumeroBoite] = struct{}{}
}

// NumeroBoiteCleared returns if the "numero_boite" field was cleared in this mutation.
func (m *EmplacementMutation) NumeroBoiteCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldNumeroBoite]
	return ok
}

// ResetNumeroBoite resets all changes to the "numero_boite" field.
func (m *EmplacementMutation) ResetNumeroBoite() {
	m.numero_boite = nil
	delete(m.clearedFields, emplacement.FieldNumeroBoite)
}

// SetIcone sets the "icone" field.
func (m *EmplacementMutation) SetIcone(s string) {
	m.icone = &s
}

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

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

// ClearIcone clears the value of the "icone" field.
func (m *EmplacementMutation) ClearIcone() {
	m.icone = nil
	m.clearedFields[emplacement.FieldIcone] = struct{}{}
}

// IconeCleared returns if the "icone" field was cleared in this mutation.
func (m *EmplacementMutation) IconeCleared() bool {
	_, ok := m.clearedFields[emplacement.FieldIcone]
	return ok
}

// ResetIcone resets all changes to the "icone" field.
func (m *EmplacementMutation) ResetIcone() {
	m.icone = nil
	delete(m.clearedFields, emplacement.FieldIcone)
}

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

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

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

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

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

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

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

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

// ClearParent clears the "parent" edge to the Emplacement entity.
func (m *EmplacementMutation) ClearParent() {
	m.clearedparent = true
	m.clearedFields[emplacement.FieldParentID] = struct{}{}
}

// ParentCleared reports if the "parent" edge to the Emplacement entity was cleared.
func (m *EmplacementMutation) ParentCleared() bool {
	return m.ParentIDCleared() || m.clearedparent
}

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

// ResetParent resets all changes to the "parent" edge.
func (m *EmplacementMutation) ResetParent() {
	m.parent = nil
	m.clearedparent = false
}

// AddEnfantIDs adds the "enfants" edge to the Emplacement entity by ids.
func (m *EmplacementMutation) AddEnfantIDs(ids ...uuid.UUID) {
	if m.enfants == nil {
		m.enfants = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.enfants[ids[i]] = struct{}{}
	}
}

// ClearEnfants clears the "enfants" edge to the Emplacement entity.
func (m *EmplacementMutation) ClearEnfants() {
	m.clearedenfants = true
}

// EnfantsCleared reports if the "enfants" edge to the Emplacement entity was cleared.
func (m *EmplacementMutation) EnfantsCleared() bool {
	return m.clearedenfants
}

// RemoveEnfantIDs removes the "enfants" edge to the Emplacement entity by IDs.
func (m *EmplacementMutation) RemoveEnfantIDs(ids ...uuid.UUID) {
	if m.removedenfants == nil {
		m.removedenfants = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.enfants, ids[i])
		m.removedenfants[ids[i]] = struct{}{}
	}
}

// RemovedEnfants returns the removed IDs of the "enfants" edge to the Emplacement entity.
func (m *EmplacementMutation) RemovedEnfantsIDs() (ids []uuid.UUID) {
	for id := range m.removedenfants {
		ids = append(ids, id)
	}
	return
}

// EnfantsIDs returns the "enfants" edge IDs in the mutation.
func (m *EmplacementMutation) EnfantsIDs() (ids []uuid.UUID) {
	for id := range m.enfants {
		ids = append(ids, id)
	}
	return
}

// ResetEnfants resets all changes to the "enfants" edge.
func (m *EmplacementMutation) ResetEnfants() {
	m.enfants = nil
	m.clearedenfants = false
	m.removedenfants = nil
}

// AddLiensObjetIDs adds the "liens_objets" edge to the LienObjetEmplacement entity by ids.
func (m *EmplacementMutation) AddLiensObjetIDs(ids ...uuid.UUID) {
	if m.liens_objets == nil {
		m.liens_objets = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.liens_objets[ids[i]] = struct{}{}
	}
}

// ClearLiensObjets clears the "liens_objets" edge to the LienObjetEmplacement entity.
func (m *EmplacementMutation) ClearLiensObjets() {
	m.clearedliens_objets = true
}

// LiensObjetsCleared reports if the "liens_objets" edge to the LienObjetEmplacement entity was cleared.
func (m *EmplacementMutation) LiensObjetsCleared() bool {
	return m.clearedliens_objets
}

// RemoveLiensObjetIDs removes the "liens_objets" edge to the LienObjetEmplacement entity by IDs.
func (m *EmplacementMutation) RemoveLiensObjetIDs(ids ...uuid.UUID) {
	if m.removedliens_objets == nil {
		m.removedliens_objets = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.liens_objets, ids[i])
		m.removedliens_objets[ids[i]] = struct{}{}
	}
}

// RemovedLiensObjets returns the removed IDs of the "liens_objets" edge to the LienObjetEmplacement entity.
func (m *EmplacementMutation) RemovedLiensObjetsIDs() (ids []uuid.UUID) {
	for id := range m.removedliens_objets {
		ids = append(ids, id)
	}
	return
}

// LiensObjetsIDs returns the "liens_objets" edge IDs in the mutation.
func (m *EmplacementMutation) LiensObjetsIDs() (ids []uuid.UUID) {
	for id := range m.liens_objets {
		ids = append(ids, id)
	}
	return
}

// ResetLiensObjets resets all changes to the "liens_objets" edge.
func (m *EmplacementMutation) ResetLiensObjets() {
	m.liens_objets = nil
	m.clearedliens_objets = false
	m.removedliens_objets = nil
}

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

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

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

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

// Type returns the node type of this mutation (Emplacement).
func (m *EmplacementMutation) 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 *EmplacementMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.nom != nil {
		fields = append(fields, emplacement.FieldNom)
	}
	if m.parent != nil {
		fields = append(fields, emplacement.FieldParentID)
	}
	if m.slug != nil {
		fields = append(fields, emplacement.FieldSlug)
	}
	if m.piece != nil {
		fields = append(fields, emplacement.FieldPiece)
	}
	if m.meuble != nil {
		fields = append(fields, emplacement.FieldMeuble)
	}
	if m.numero_boite != nil {
		fields = append(fields, emplacement.FieldNumeroBoite)
	}
	if m.icone != nil {
		fields = append(fields, emplacement.FieldIcone)
	}
	if m.created_at != nil {
		fields = append(fields, emplacement.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, emplacement.FieldUpdatedAt)
	}
	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 *EmplacementMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case emplacement.FieldNom:
		return m.Nom()
	case emplacement.FieldParentID:
		return m.ParentID()
	case emplacement.FieldSlug:
		return m.Slug()
	case emplacement.FieldPiece:
		return m.Piece()
	case emplacement.FieldMeuble:
		return m.Meuble()
	case emplacement.FieldNumeroBoite:
		return m.NumeroBoite()
	case emplacement.FieldIcone:
		return m.Icone()
	case emplacement.FieldCreatedAt:
		return m.CreatedAt()
	case emplacement.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *EmplacementMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case emplacement.FieldNom:
		return m.OldNom(ctx)
	case emplacement.FieldParentID:
		return m.OldParentID(ctx)
	case emplacement.FieldSlug:
		return m.OldSlug(ctx)
	case emplacement.FieldPiece:
		return m.OldPiece(ctx)
	case emplacement.FieldMeuble:
		return m.OldMeuble(ctx)
	case emplacement.FieldNumeroBoite:
		return m.OldNumeroBoite(ctx)
	case emplacement.FieldIcone:
		return m.OldIcone(ctx)
	case emplacement.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case emplacement.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Emplacement 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 *EmplacementMutation) SetField(name string, value ent.Value) error {
	switch name {
	case emplacement.FieldNom:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNom(v)
		return nil
	case emplacement.FieldParentID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetParentID(v)
		return nil
	case emplacement.FieldSlug:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSlug(v)
		return nil
	case emplacement.FieldPiece:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPiece(v)
		return nil
	case emplacement.FieldMeuble:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMeuble(v)
		return nil
	case emplacement.FieldNumeroBoite:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNumeroBoite(v)
		return nil
	case emplacement.FieldIcone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIcone(v)
		return nil
	case emplacement.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case emplacement.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Emplacement field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *EmplacementMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(emplacement.FieldParentID) {
		fields = append(fields, emplacement.FieldParentID)
	}
	if m.FieldCleared(emplacement.FieldSlug) {
		fields = append(fields, emplacement.FieldSlug)
	}
	if m.FieldCleared(emplacement.FieldPiece) {
		fields = append(fields, emplacement.FieldPiece)
	}
	if m.FieldCleared(emplacement.FieldMeuble) {
		fields = append(fields, emplacement.FieldMeuble)
	}
	if m.FieldCleared(emplacement.FieldNumeroBoite) {
		fields = append(fields, emplacement.FieldNumeroBoite)
	}
	if m.FieldCleared(emplacement.FieldIcone) {
		fields = append(fields, emplacement.FieldIcone)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *EmplacementMutation) 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 *EmplacementMutation) ClearField(name string) error {
	switch name {
	case emplacement.FieldParentID:
		m.ClearParentID()
		return nil
	case emplacement.FieldSlug:
		m.ClearSlug()
		return nil
	case emplacement.FieldPiece:
		m.ClearPiece()
		return nil
	case emplacement.FieldMeuble:
		m.ClearMeuble()
		return nil
	case emplacement.FieldNumeroBoite:
		m.ClearNumeroBoite()
		return nil
	case emplacement.FieldIcone:
		m.ClearIcone()
		return nil
	}
	return fmt.Errorf("unknown Emplacement 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 *EmplacementMutation) ResetField(name string) error {
	switch name {
	case emplacement.FieldNom:
		m.ResetNom()
		return nil
	case emplacement.FieldParentID:
		m.ResetParentID()
		return nil
	case emplacement.FieldSlug:
		m.ResetSlug()
		return nil
	case emplacement.FieldPiece:
		m.ResetPiece()
		return nil
	case emplacement.FieldMeuble:
		m.ResetMeuble()
		return nil
	case emplacement.FieldNumeroBoite:
		m.ResetNumeroBoite()
		return nil
	case emplacement.FieldIcone:
		m.ResetIcone()
		return nil
	case emplacement.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case emplacement.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown Emplacement field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *EmplacementMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.parent != nil {
		edges = append(edges, emplacement.EdgeParent)
	}
	if m.enfants != nil {
		edges = append(edges, emplacement.EdgeEnfants)
	}
	if m.liens_objets != nil {
		edges = append(edges, emplacement.EdgeLiensObjets)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *EmplacementMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case emplacement.EdgeParent:
		if id := m.parent; id != nil {
			return []ent.Value{*id}
		}
	case emplacement.EdgeEnfants:
		ids := make([]ent.Value, 0, len(m.enfants))
		for id := range m.enfants {
			ids = append(ids, id)
		}
		return ids
	case emplacement.EdgeLiensObjets:
		ids := make([]ent.Value, 0, len(m.liens_objets))
		for id := range m.liens_objets {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *EmplacementMutation) RemovedEdges() []string {
	edges := make([]string, 0, 3)
	if m.removedenfants != nil {
		edges = append(edges, emplacement.EdgeEnfants)
	}
	if m.removedliens_objets != nil {
		edges = append(edges, emplacement.EdgeLiensObjets)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *EmplacementMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedparent {
		edges = append(edges, emplacement.EdgeParent)
	}
	if m.clearedenfants {
		edges = append(edges, emplacement.EdgeEnfants)
	}
	if m.clearedliens_objets {
		edges = append(edges, emplacement.EdgeLiensObjets)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *EmplacementMutation) EdgeCleared(name string) bool {
	switch name {
	case emplacement.EdgeParent:
		return m.clearedparent
	case emplacement.EdgeEnfants:
		return m.clearedenfants
	case emplacement.EdgeLiensObjets:
		return m.clearedliens_objets
	}
	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 *EmplacementMutation) ClearEdge(name string) error {
	switch name {
	case emplacement.EdgeParent:
		m.ClearParent()
		return nil
	}
	return fmt.Errorf("unknown Emplacement 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 *EmplacementMutation) ResetEdge(name string) error {
	switch name {
	case emplacement.EdgeParent:
		m.ResetParent()
		return nil
	case emplacement.EdgeEnfants:
		m.ResetEnfants()
		return nil
	case emplacement.EdgeLiensObjets:
		m.ResetLiensObjets()
		return nil
	}
	return fmt.Errorf("unknown Emplacement edge %s", name)
}

// LienObjetEmplacementMutation represents an operation that mutates the LienObjetEmplacement nodes in the graph.
type LienObjetEmplacementMutation struct {
	config
	op                 Op
	typ                string
	id                 *uuid.UUID
	_type              *lienobjetemplacement.Type
	created_at         *time.Time
	updated_at         *time.Time
	clearedFields      map[string]struct{}
	objet              *uuid.UUID
	clearedobjet       bool
	emplacement        *uuid.UUID
	clearedemplacement bool
	done               bool
	oldValue           func(context.Context) (*LienObjetEmplacement, error)
	predicates         []predicate.LienObjetEmplacement
}

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

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

// newLienObjetEmplacementMutation creates new mutation for the LienObjetEmplacement entity.
func newLienObjetEmplacementMutation(c config, op Op, opts ...lienobjetemplacementOption) *LienObjetEmplacementMutation {
	m := &LienObjetEmplacementMutation{
		config:        c,
		op:            op,
		typ:           TypeLienObjetEmplacement,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetObjetID sets the "objet_id" field.
func (m *LienObjetEmplacementMutation) SetObjetID(u uuid.UUID) {
	m.objet = &u
}

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

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

// ResetObjetID resets all changes to the "objet_id" field.
func (m *LienObjetEmplacementMutation) ResetObjetID() {
	m.objet = nil
}

// SetEmplacementID sets the "emplacement_id" field.
func (m *LienObjetEmplacementMutation) SetEmplacementID(u uuid.UUID) {
	m.emplacement = &u
}

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

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

// ResetEmplacementID resets all changes to the "emplacement_id" field.
func (m *LienObjetEmplacementMutation) ResetEmplacementID() {
	m.emplacement = nil
}

// SetType sets the "type" field.
func (m *LienObjetEmplacementMutation) SetType(l lienobjetemplacement.Type) {
	m._type = &l
}

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

// OldType returns the old "type" field's value of the LienObjetEmplacement entity.
// If the LienObjetEmplacement 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 *LienObjetEmplacementMutation) OldType(ctx context.Context) (v lienobjetemplacement.Type, 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 *LienObjetEmplacementMutation) ResetType() {
	m._type = nil
}

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

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

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

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

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

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

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

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

// ClearObjet clears the "objet" edge to the Objet entity.
func (m *LienObjetEmplacementMutation) ClearObjet() {
	m.clearedobjet = true
	m.clearedFields[lienobjetemplacement.FieldObjetID] = struct{}{}
}

// ObjetCleared reports if the "objet" edge to the Objet entity was cleared.
func (m *LienObjetEmplacementMutation) ObjetCleared() bool {
	return m.clearedobjet
}

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

// ResetObjet resets all changes to the "objet" edge.
func (m *LienObjetEmplacementMutation) ResetObjet() {
	m.objet = nil
	m.clearedobjet = false
}

// ClearEmplacement clears the "emplacement" edge to the Emplacement entity.
func (m *LienObjetEmplacementMutation) ClearEmplacement() {
	m.clearedemplacement = true
	m.clearedFields[lienobjetemplacement.FieldEmplacementID] = struct{}{}
}

// EmplacementCleared reports if the "emplacement" edge to the Emplacement entity was cleared.
func (m *LienObjetEmplacementMutation) EmplacementCleared() bool {
	return m.clearedemplacement
}

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

// ResetEmplacement resets all changes to the "emplacement" edge.
func (m *LienObjetEmplacementMutation) ResetEmplacement() {
	m.emplacement = nil
	m.clearedemplacement = false
}

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

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

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

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

// Type returns the node type of this mutation (LienObjetEmplacement).
func (m *LienObjetEmplacementMutation) 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 *LienObjetEmplacementMutation) Fields() []string {
	fields := make([]string, 0, 5)
	if m.objet != nil {
		fields = append(fields, lienobjetemplacement.FieldObjetID)
	}
	if m.emplacement != nil {
		fields = append(fields, lienobjetemplacement.FieldEmplacementID)
	}
	if m._type != nil {
		fields = append(fields, lienobjetemplacement.FieldType)
	}
	if m.created_at != nil {
		fields = append(fields, lienobjetemplacement.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, lienobjetemplacement.FieldUpdatedAt)
	}
	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 *LienObjetEmplacementMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case lienobjetemplacement.FieldObjetID:
		return m.ObjetID()
	case lienobjetemplacement.FieldEmplacementID:
		return m.EmplacementID()
	case lienobjetemplacement.FieldType:
		return m.GetType()
	case lienobjetemplacement.FieldCreatedAt:
		return m.CreatedAt()
	case lienobjetemplacement.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *LienObjetEmplacementMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case lienobjetemplacement.FieldObjetID:
		return m.OldObjetID(ctx)
	case lienobjetemplacement.FieldEmplacementID:
		return m.OldEmplacementID(ctx)
	case lienobjetemplacement.FieldType:
		return m.OldType(ctx)
	case lienobjetemplacement.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case lienobjetemplacement.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown LienObjetEmplacement 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 *LienObjetEmplacementMutation) SetField(name string, value ent.Value) error {
	switch name {
	case lienobjetemplacement.FieldObjetID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetObjetID(v)
		return nil
	case lienobjetemplacement.FieldEmplacementID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmplacementID(v)
		return nil
	case lienobjetemplacement.FieldType:
		v, ok := value.(lienobjetemplacement.Type)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case lienobjetemplacement.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case lienobjetemplacement.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown LienObjetEmplacement field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *LienObjetEmplacementMutation) 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 *LienObjetEmplacementMutation) ClearField(name string) error {
	return fmt.Errorf("unknown LienObjetEmplacement 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 *LienObjetEmplacementMutation) ResetField(name string) error {
	switch name {
	case lienobjetemplacement.FieldObjetID:
		m.ResetObjetID()
		return nil
	case lienobjetemplacement.FieldEmplacementID:
		m.ResetEmplacementID()
		return nil
	case lienobjetemplacement.FieldType:
		m.ResetType()
		return nil
	case lienobjetemplacement.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case lienobjetemplacement.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown LienObjetEmplacement field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *LienObjetEmplacementMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.objet != nil {
		edges = append(edges, lienobjetemplacement.EdgeObjet)
	}
	if m.emplacement != nil {
		edges = append(edges, lienobjetemplacement.EdgeEmplacement)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *LienObjetEmplacementMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedobjet {
		edges = append(edges, lienobjetemplacement.EdgeObjet)
	}
	if m.clearedemplacement {
		edges = append(edges, lienobjetemplacement.EdgeEmplacement)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *LienObjetEmplacementMutation) EdgeCleared(name string) bool {
	switch name {
	case lienobjetemplacement.EdgeObjet:
		return m.clearedobjet
	case lienobjetemplacement.EdgeEmplacement:
		return m.clearedemplacement
	}
	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 *LienObjetEmplacementMutation) ClearEdge(name string) error {
	switch name {
	case lienobjetemplacement.EdgeObjet:
		m.ClearObjet()
		return nil
	case lienobjetemplacement.EdgeEmplacement:
		m.ClearEmplacement()
		return nil
	}
	return fmt.Errorf("unknown LienObjetEmplacement 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 *LienObjetEmplacementMutation) ResetEdge(name string) error {
	switch name {
	case lienobjetemplacement.EdgeObjet:
		m.ResetObjet()
		return nil
	case lienobjetemplacement.EdgeEmplacement:
		m.ResetEmplacement()
		return nil
	}
	return fmt.Errorf("unknown LienObjetEmplacement edge %s", name)
}

// ObjetMutation represents an operation that mutates the Objet nodes in the graph.
type ObjetMutation struct {
	config
	op                          Op
	typ                         string
	id                          *uuid.UUID
	nom                         *string
	description                 *string
	quantite                    *int
	addquantite                 *int
	prix_achat                  *float64
	addprix_achat               *float64
	date_achat                  *time.Time
	boutique                    *string
	numero_serie                *string
	numero_modele               *string
	fabricant                   *string
	statut                      *objet.Statut
	caracteristiques            *map[string]interface{}
	created_at                  *time.Time
	updated_at                  *time.Time
	clearedFields               map[string]struct{}
	liens_emplacements          map[uuid.UUID]struct{}
	removedliens_emplacements   map[uuid.UUID]struct{}
	clearedliens_emplacements   bool
	champs_personnalises        map[uuid.UUID]struct{}
	removedchamps_personnalises map[uuid.UUID]struct{}
	clearedchamps_personnalises bool
	pieces_jointes              map[uuid.UUID]struct{}
	removedpieces_jointes       map[uuid.UUID]struct{}
	clearedpieces_jointes       bool
	done                        bool
	oldValue                    func(context.Context) (*Objet, error)
	predicates                  []predicate.Objet
}

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

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

// newObjetMutation creates new mutation for the Objet entity.
func newObjetMutation(c config, op Op, opts ...objetOption) *ObjetMutation {
	m := &ObjetMutation{
		config:        c,
		op:            op,
		typ:           TypeObjet,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetNom sets the "nom" field.
func (m *ObjetMutation) SetNom(s string) {
	m.nom = &s
}

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

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

// ResetNom resets all changes to the "nom" field.
func (m *ObjetMutation) ResetNom() {
	m.nom = nil
}

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

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

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

// ClearDescription clears the value of the "description" field.
func (m *ObjetMutation) ClearDescription() {
	m.description = nil
	m.clearedFields[objet.FieldDescription] = struct{}{}
}

// DescriptionCleared returns if the "description" field was cleared in this mutation.
func (m *ObjetMutation) DescriptionCleared() bool {
	_, ok := m.clearedFields[objet.FieldDescription]
	return ok
}

// ResetDescription resets all changes to the "description" field.
func (m *ObjetMutation) ResetDescription() {
	m.description = nil
	delete(m.clearedFields, objet.FieldDescription)
}

// SetQuantite sets the "quantite" field.
func (m *ObjetMutation) SetQuantite(i int) {
	m.quantite = &i
	m.addquantite = nil
}

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

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

// AddQuantite adds i to the "quantite" field.
func (m *ObjetMutation) AddQuantite(i int) {
	if m.addquantite != nil {
		*m.addquantite += i
	} else {
		m.addquantite = &i
	}
}

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

// ResetQuantite resets all changes to the "quantite" field.
func (m *ObjetMutation) ResetQuantite() {
	m.quantite = nil
	m.addquantite = nil
}

// SetPrixAchat sets the "prix_achat" field.
func (m *ObjetMutation) SetPrixAchat(f float64) {
	m.prix_achat = &f
	m.addprix_achat = nil
}

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

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

// AddPrixAchat adds f to the "prix_achat" field.
func (m *ObjetMutation) AddPrixAchat(f float64) {
	if m.addprix_achat != nil {
		*m.addprix_achat += f
	} else {
		m.addprix_achat = &f
	}
}

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

// ClearPrixAchat clears the value of the "prix_achat" field.
func (m *ObjetMutation) ClearPrixAchat() {
	m.prix_achat = nil
	m.addprix_achat = nil
	m.clearedFields[objet.FieldPrixAchat] = struct{}{}
}

// PrixAchatCleared returns if the "prix_achat" field was cleared in this mutation.
func (m *ObjetMutation) PrixAchatCleared() bool {
	_, ok := m.clearedFields[objet.FieldPrixAchat]
	return ok
}

// ResetPrixAchat resets all changes to the "prix_achat" field.
func (m *ObjetMutation) ResetPrixAchat() {
	m.prix_achat = nil
	m.addprix_achat = nil
	delete(m.clearedFields, objet.FieldPrixAchat)
}

// SetDateAchat sets the "date_achat" field.
func (m *ObjetMutation) SetDateAchat(t time.Time) {
	m.date_achat = &t
}

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

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

// ClearDateAchat clears the value of the "date_achat" field.
func (m *ObjetMutation) ClearDateAchat() {
	m.date_achat = nil
	m.clearedFields[objet.FieldDateAchat] = struct{}{}
}

// DateAchatCleared returns if the "date_achat" field was cleared in this mutation.
func (m *ObjetMutation) DateAchatCleared() bool {
	_, ok := m.clearedFields[objet.FieldDateAchat]
	return ok
}

// ResetDateAchat resets all changes to the "date_achat" field.
func (m *ObjetMutation) ResetDateAchat() {
	m.date_achat = nil
	delete(m.clearedFields, objet.FieldDateAchat)
}

// SetBoutique sets the "boutique" field.
func (m *ObjetMutation) SetBoutique(s string) {
	m.boutique = &s
}

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

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

// ClearBoutique clears the value of the "boutique" field.
func (m *ObjetMutation) ClearBoutique() {
	m.boutique = nil
	m.clearedFields[objet.FieldBoutique] = struct{}{}
}

// BoutiqueCleared returns if the "boutique" field was cleared in this mutation.
func (m *ObjetMutation) BoutiqueCleared() bool {
	_, ok := m.clearedFields[objet.FieldBoutique]
	return ok
}

// ResetBoutique resets all changes to the "boutique" field.
func (m *ObjetMutation) ResetBoutique() {
	m.boutique = nil
	delete(m.clearedFields, objet.FieldBoutique)
}

// SetNumeroSerie sets the "numero_serie" field.
func (m *ObjetMutation) SetNumeroSerie(s string) {
	m.numero_serie = &s
}

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

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

// ClearNumeroSerie clears the value of the "numero_serie" field.
func (m *ObjetMutation) ClearNumeroSerie() {
	m.numero_serie = nil
	m.clearedFields[objet.FieldNumeroSerie] = struct{}{}
}

// NumeroSerieCleared returns if the "numero_serie" field was cleared in this mutation.
func (m *ObjetMutation) NumeroSerieCleared() bool {
	_, ok := m.clearedFields[objet.FieldNumeroSerie]
	return ok
}

// ResetNumeroSerie resets all changes to the "numero_serie" field.
func (m *ObjetMutation) ResetNumeroSerie() {
	m.numero_serie = nil
	delete(m.clearedFields, objet.FieldNumeroSerie)
}

// SetNumeroModele sets the "numero_modele" field.
func (m *ObjetMutation) SetNumeroModele(s string) {
	m.numero_modele = &s
}

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

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

// ClearNumeroModele clears the value of the "numero_modele" field.
func (m *ObjetMutation) ClearNumeroModele() {
	m.numero_modele = nil
	m.clearedFields[objet.FieldNumeroModele] = struct{}{}
}

// NumeroModeleCleared returns if the "numero_modele" field was cleared in this mutation.
func (m *ObjetMutation) NumeroModeleCleared() bool {
	_, ok := m.clearedFields[objet.FieldNumeroModele]
	return ok
}

// ResetNumeroModele resets all changes to the "numero_modele" field.
func (m *ObjetMutation) ResetNumeroModele() {
	m.numero_modele = nil
	delete(m.clearedFields, objet.FieldNumeroModele)
}

// SetFabricant sets the "fabricant" field.
func (m *ObjetMutation) SetFabricant(s string) {
	m.fabricant = &s
}

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

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

// ClearFabricant clears the value of the "fabricant" field.
func (m *ObjetMutation) ClearFabricant() {
	m.fabricant = nil
	m.clearedFields[objet.FieldFabricant] = struct{}{}
}

// FabricantCleared returns if the "fabricant" field was cleared in this mutation.
func (m *ObjetMutation) FabricantCleared() bool {
	_, ok := m.clearedFields[objet.FieldFabricant]
	return ok
}

// ResetFabricant resets all changes to the "fabricant" field.
func (m *ObjetMutation) ResetFabricant() {
	m.fabricant = nil
	delete(m.clearedFields, objet.FieldFabricant)
}

// SetStatut sets the "statut" field.
func (m *ObjetMutation) SetStatut(o objet.Statut) {
	m.statut = &o
}

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

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

// ResetStatut resets all changes to the "statut" field.
func (m *ObjetMutation) ResetStatut() {
	m.statut = nil
}

// SetCaracteristiques sets the "caracteristiques" field.
func (m *ObjetMutation) SetCaracteristiques(value map[string]interface{}) {
	m.caracteristiques = &value
}

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

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

// ClearCaracteristiques clears the value of the "caracteristiques" field.
func (m *ObjetMutation) ClearCaracteristiques() {
	m.caracteristiques = nil
	m.clearedFields[objet.FieldCaracteristiques] = struct{}{}
}

// CaracteristiquesCleared returns if the "caracteristiques" field was cleared in this mutation.
func (m *ObjetMutation) CaracteristiquesCleared() bool {
	_, ok := m.clearedFields[objet.FieldCaracteristiques]
	return ok
}

// ResetCaracteristiques resets all changes to the "caracteristiques" field.
func (m *ObjetMutation) ResetCaracteristiques() {
	m.caracteristiques = nil
	delete(m.clearedFields, objet.FieldCaracteristiques)
}

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

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

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

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

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

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

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

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

// AddLiensEmplacementIDs adds the "liens_emplacements" edge to the LienObjetEmplacement entity by ids.
func (m *ObjetMutation) AddLiensEmplacementIDs(ids ...uuid.UUID) {
	if m.liens_emplacements == nil {
		m.liens_emplacements = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.liens_emplacements[ids[i]] = struct{}{}
	}
}

// ClearLiensEmplacements clears the "liens_emplacements" edge to the LienObjetEmplacement entity.
func (m *ObjetMutation) ClearLiensEmplacements() {
	m.clearedliens_emplacements = true
}

// LiensEmplacementsCleared reports if the "liens_emplacements" edge to the LienObjetEmplacement entity was cleared.
func (m *ObjetMutation) LiensEmplacementsCleared() bool {
	return m.clearedliens_emplacements
}

// RemoveLiensEmplacementIDs removes the "liens_emplacements" edge to the LienObjetEmplacement entity by IDs.
func (m *ObjetMutation) RemoveLiensEmplacementIDs(ids ...uuid.UUID) {
	if m.removedliens_emplacements == nil {
		m.removedliens_emplacements = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.liens_emplacements, ids[i])
		m.removedliens_emplacements[ids[i]] = struct{}{}
	}
}

// RemovedLiensEmplacements returns the removed IDs of the "liens_emplacements" edge to the LienObjetEmplacement entity.
func (m *ObjetMutation) RemovedLiensEmplacementsIDs() (ids []uuid.UUID) {
	for id := range m.removedliens_emplacements {
		ids = append(ids, id)
	}
	return
}

// LiensEmplacementsIDs returns the "liens_emplacements" edge IDs in the mutation.
func (m *ObjetMutation) LiensEmplacementsIDs() (ids []uuid.UUID) {
	for id := range m.liens_emplacements {
		ids = append(ids, id)
	}
	return
}

// ResetLiensEmplacements resets all changes to the "liens_emplacements" edge.
func (m *ObjetMutation) ResetLiensEmplacements() {
	m.liens_emplacements = nil
	m.clearedliens_emplacements = false
	m.removedliens_emplacements = nil
}

// AddChampsPersonnaliseIDs adds the "champs_personnalises" edge to the ChampPersonnalise entity by ids.
func (m *ObjetMutation) AddChampsPersonnaliseIDs(ids ...uuid.UUID) {
	if m.champs_personnalises == nil {
		m.champs_personnalises = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.champs_personnalises[ids[i]] = struct{}{}
	}
}

// ClearChampsPersonnalises clears the "champs_personnalises" edge to the ChampPersonnalise entity.
func (m *ObjetMutation) ClearChampsPersonnalises() {
	m.clearedchamps_personnalises = true
}

// ChampsPersonnalisesCleared reports if the "champs_personnalises" edge to the ChampPersonnalise entity was cleared.
func (m *ObjetMutation) ChampsPersonnalisesCleared() bool {
	return m.clearedchamps_personnalises
}

// RemoveChampsPersonnaliseIDs removes the "champs_personnalises" edge to the ChampPersonnalise entity by IDs.
func (m *ObjetMutation) RemoveChampsPersonnaliseIDs(ids ...uuid.UUID) {
	if m.removedchamps_personnalises == nil {
		m.removedchamps_personnalises = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.champs_personnalises, ids[i])
		m.removedchamps_personnalises[ids[i]] = struct{}{}
	}
}

// RemovedChampsPersonnalises returns the removed IDs of the "champs_personnalises" edge to the ChampPersonnalise entity.
func (m *ObjetMutation) RemovedChampsPersonnalisesIDs() (ids []uuid.UUID) {
	for id := range m.removedchamps_personnalises {
		ids = append(ids, id)
	}
	return
}

// ChampsPersonnalisesIDs returns the "champs_personnalises" edge IDs in the mutation.
func (m *ObjetMutation) ChampsPersonnalisesIDs() (ids []uuid.UUID) {
	for id := range m.champs_personnalises {
		ids = append(ids, id)
	}
	return
}

// ResetChampsPersonnalises resets all changes to the "champs_personnalises" edge.
func (m *ObjetMutation) ResetChampsPersonnalises() {
	m.champs_personnalises = nil
	m.clearedchamps_personnalises = false
	m.removedchamps_personnalises = nil
}

// AddPiecesJointeIDs adds the "pieces_jointes" edge to the PieceJointe entity by ids.
func (m *ObjetMutation) AddPiecesJointeIDs(ids ...uuid.UUID) {
	if m.pieces_jointes == nil {
		m.pieces_jointes = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.pieces_jointes[ids[i]] = struct{}{}
	}
}

// ClearPiecesJointes clears the "pieces_jointes" edge to the PieceJointe entity.
func (m *ObjetMutation) ClearPiecesJointes() {
	m.clearedpieces_jointes = true
}

// PiecesJointesCleared reports if the "pieces_jointes" edge to the PieceJointe entity was cleared.
func (m *ObjetMutation) PiecesJointesCleared() bool {
	return m.clearedpieces_jointes
}

// RemovePiecesJointeIDs removes the "pieces_jointes" edge to the PieceJointe entity by IDs.
func (m *ObjetMutation) RemovePiecesJointeIDs(ids ...uuid.UUID) {
	if m.removedpieces_jointes == nil {
		m.removedpieces_jointes = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.pieces_jointes, ids[i])
		m.removedpieces_jointes[ids[i]] = struct{}{}
	}
}

// RemovedPiecesJointes returns the removed IDs of the "pieces_jointes" edge to the PieceJointe entity.
func (m *ObjetMutation) RemovedPiecesJointesIDs() (ids []uuid.UUID) {
	for id := range m.removedpieces_jointes {
		ids = append(ids, id)
	}
	return
}

// PiecesJointesIDs returns the "pieces_jointes" edge IDs in the mutation.
func (m *ObjetMutation) PiecesJointesIDs() (ids []uuid.UUID) {
	for id := range m.pieces_jointes {
		ids = append(ids, id)
	}
	return
}

// ResetPiecesJointes resets all changes to the "pieces_jointes" edge.
func (m *ObjetMutation) ResetPiecesJointes() {
	m.pieces_jointes = nil
	m.clearedpieces_jointes = false
	m.removedpieces_jointes = nil
}

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

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

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

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

// Type returns the node type of this mutation (Objet).
func (m *ObjetMutation) 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 *ObjetMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.nom != nil {
		fields = append(fields, objet.FieldNom)
	}
	if m.description != nil {
		fields = append(fields, objet.FieldDescription)
	}
	if m.quantite != nil {
		fields = append(fields, objet.FieldQuantite)
	}
	if m.prix_achat != nil {
		fields = append(fields, objet.FieldPrixAchat)
	}
	if m.date_achat != nil {
		fields = append(fields, objet.FieldDateAchat)
	}
	if m.boutique != nil {
		fields = append(fields, objet.FieldBoutique)
	}
	if m.numero_serie != nil {
		fields = append(fields, objet.FieldNumeroSerie)
	}
	if m.numero_modele != nil {
		fields = append(fields, objet.FieldNumeroModele)
	}
	if m.fabricant != nil {
		fields = append(fields, objet.FieldFabricant)
	}
	if m.statut != nil {
		fields = append(fields, objet.FieldStatut)
	}
	if m.caracteristiques != nil {
		fields = append(fields, objet.FieldCaracteristiques)
	}
	if m.created_at != nil {
		fields = append(fields, objet.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, objet.FieldUpdatedAt)
	}
	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 *ObjetMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case objet.FieldNom:
		return m.Nom()
	case objet.FieldDescription:
		return m.Description()
	case objet.FieldQuantite:
		return m.Quantite()
	case objet.FieldPrixAchat:
		return m.PrixAchat()
	case objet.FieldDateAchat:
		return m.DateAchat()
	case objet.FieldBoutique:
		return m.Boutique()
	case objet.FieldNumeroSerie:
		return m.NumeroSerie()
	case objet.FieldNumeroModele:
		return m.NumeroModele()
	case objet.FieldFabricant:
		return m.Fabricant()
	case objet.FieldStatut:
		return m.Statut()
	case objet.FieldCaracteristiques:
		return m.Caracteristiques()
	case objet.FieldCreatedAt:
		return m.CreatedAt()
	case objet.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *ObjetMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case objet.FieldNom:
		return m.OldNom(ctx)
	case objet.FieldDescription:
		return m.OldDescription(ctx)
	case objet.FieldQuantite:
		return m.OldQuantite(ctx)
	case objet.FieldPrixAchat:
		return m.OldPrixAchat(ctx)
	case objet.FieldDateAchat:
		return m.OldDateAchat(ctx)
	case objet.FieldBoutique:
		return m.OldBoutique(ctx)
	case objet.FieldNumeroSerie:
		return m.OldNumeroSerie(ctx)
	case objet.FieldNumeroModele:
		return m.OldNumeroModele(ctx)
	case objet.FieldFabricant:
		return m.OldFabricant(ctx)
	case objet.FieldStatut:
		return m.OldStatut(ctx)
	case objet.FieldCaracteristiques:
		return m.OldCaracteristiques(ctx)
	case objet.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case objet.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Objet 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 *ObjetMutation) SetField(name string, value ent.Value) error {
	switch name {
	case objet.FieldNom:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNom(v)
		return nil
	case objet.FieldDescription:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDescription(v)
		return nil
	case objet.FieldQuantite:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetQuantite(v)
		return nil
	case objet.FieldPrixAchat:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPrixAchat(v)
		return nil
	case objet.FieldDateAchat:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDateAchat(v)
		return nil
	case objet.FieldBoutique:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBoutique(v)
		return nil
	case objet.FieldNumeroSerie:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNumeroSerie(v)
		return nil
	case objet.FieldNumeroModele:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNumeroModele(v)
		return nil
	case objet.FieldFabricant:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFabricant(v)
		return nil
	case objet.FieldStatut:
		v, ok := value.(objet.Statut)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatut(v)
		return nil
	case objet.FieldCaracteristiques:
		v, ok := value.(map[string]interface{})
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCaracteristiques(v)
		return nil
	case objet.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case objet.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Objet field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ObjetMutation) AddedFields() []string {
	var fields []string
	if m.addquantite != nil {
		fields = append(fields, objet.FieldQuantite)
	}
	if m.addprix_achat != nil {
		fields = append(fields, objet.FieldPrixAchat)
	}
	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 *ObjetMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case objet.FieldQuantite:
		return m.AddedQuantite()
	case objet.FieldPrixAchat:
		return m.AddedPrixAchat()
	}
	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 *ObjetMutation) AddField(name string, value ent.Value) error {
	switch name {
	case objet.FieldQuantite:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddQuantite(v)
		return nil
	case objet.FieldPrixAchat:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPrixAchat(v)
		return nil
	}
	return fmt.Errorf("unknown Objet numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ObjetMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(objet.FieldDescription) {
		fields = append(fields, objet.FieldDescription)
	}
	if m.FieldCleared(objet.FieldPrixAchat) {
		fields = append(fields, objet.FieldPrixAchat)
	}
	if m.FieldCleared(objet.FieldDateAchat) {
		fields = append(fields, objet.FieldDateAchat)
	}
	if m.FieldCleared(objet.FieldBoutique) {
		fields = append(fields, objet.FieldBoutique)
	}
	if m.FieldCleared(objet.FieldNumeroSerie) {
		fields = append(fields, objet.FieldNumeroSerie)
	}
	if m.FieldCleared(objet.FieldNumeroModele) {
		fields = append(fields, objet.FieldNumeroModele)
	}
	if m.FieldCleared(objet.FieldFabricant) {
		fields = append(fields, objet.FieldFabricant)
	}
	if m.FieldCleared(objet.FieldCaracteristiques) {
		fields = append(fields, objet.FieldCaracteristiques)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ObjetMutation) 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 *ObjetMutation) ClearField(name string) error {
	switch name {
	case objet.FieldDescription:
		m.ClearDescription()
		return nil
	case objet.FieldPrixAchat:
		m.ClearPrixAchat()
		return nil
	case objet.FieldDateAchat:
		m.ClearDateAchat()
		return nil
	case objet.FieldBoutique:
		m.ClearBoutique()
		return nil
	case objet.FieldNumeroSerie:
		m.ClearNumeroSerie()
		return nil
	case objet.FieldNumeroModele:
		m.ClearNumeroModele()
		return nil
	case objet.FieldFabricant:
		m.ClearFabricant()
		return nil
	case objet.FieldCaracteristiques:
		m.ClearCaracteristiques()
		return nil
	}
	return fmt.Errorf("unknown Objet 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 *ObjetMutation) ResetField(name string) error {
	switch name {
	case objet.FieldNom:
		m.ResetNom()
		return nil
	case objet.FieldDescription:
		m.ResetDescription()
		return nil
	case objet.FieldQuantite:
		m.ResetQuantite()
		return nil
	case objet.FieldPrixAchat:
		m.ResetPrixAchat()
		return nil
	case objet.FieldDateAchat:
		m.ResetDateAchat()
		return nil
	case objet.FieldBoutique:
		m.ResetBoutique()
		return nil
	case objet.FieldNumeroSerie:
		m.ResetNumeroSerie()
		return nil
	case objet.FieldNumeroModele:
		m.ResetNumeroModele()
		return nil
	case objet.FieldFabricant:
		m.ResetFabricant()
		return nil
	case objet.FieldStatut:
		m.ResetStatut()
		return nil
	case objet.FieldCaracteristiques:
		m.ResetCaracteristiques()
		return nil
	case objet.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case objet.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown Objet field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *ObjetMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.liens_emplacements != nil {
		edges = append(edges, objet.EdgeLiensEmplacements)
	}
	if m.champs_personnalises != nil {
		edges = append(edges, objet.EdgeChampsPersonnalises)
	}
	if m.pieces_jointes != nil {
		edges = append(edges, objet.EdgePiecesJointes)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *ObjetMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case objet.EdgeLiensEmplacements:
		ids := make([]ent.Value, 0, len(m.liens_emplacements))
		for id := range m.liens_emplacements {
			ids = append(ids, id)
		}
		return ids
	case objet.EdgeChampsPersonnalises:
		ids := make([]ent.Value, 0, len(m.champs_personnalises))
		for id := range m.champs_personnalises {
			ids = append(ids, id)
		}
		return ids
	case objet.EdgePiecesJointes:
		ids := make([]ent.Value, 0, len(m.pieces_jointes))
		for id := range m.pieces_jointes {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *ObjetMutation) RemovedEdges() []string {
	edges := make([]string, 0, 3)
	if m.removedliens_emplacements != nil {
		edges = append(edges, objet.EdgeLiensEmplacements)
	}
	if m.removedchamps_personnalises != nil {
		edges = append(edges, objet.EdgeChampsPersonnalises)
	}
	if m.removedpieces_jointes != nil {
		edges = append(edges, objet.EdgePiecesJointes)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *ObjetMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case objet.EdgeLiensEmplacements:
		ids := make([]ent.Value, 0, len(m.removedliens_emplacements))
		for id := range m.removedliens_emplacements {
			ids = append(ids, id)
		}
		return ids
	case objet.EdgeChampsPersonnalises:
		ids := make([]ent.Value, 0, len(m.removedchamps_personnalises))
		for id := range m.removedchamps_personnalises {
			ids = append(ids, id)
		}
		return ids
	case objet.EdgePiecesJointes:
		ids := make([]ent.Value, 0, len(m.removedpieces_jointes))
		for id := range m.removedpieces_jointes {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ObjetMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedliens_emplacements {
		edges = append(edges, objet.EdgeLiensEmplacements)
	}
	if m.clearedchamps_personnalises {
		edges = append(edges, objet.EdgeChampsPersonnalises)
	}
	if m.clearedpieces_jointes {
		edges = append(edges, objet.EdgePiecesJointes)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ObjetMutation) EdgeCleared(name string) bool {
	switch name {
	case objet.EdgeLiensEmplacements:
		return m.clearedliens_emplacements
	case objet.EdgeChampsPersonnalises:
		return m.clearedchamps_personnalises
	case objet.EdgePiecesJointes:
		return m.clearedpieces_jointes
	}
	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 *ObjetMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Objet 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 *ObjetMutation) ResetEdge(name string) error {
	switch name {
	case objet.EdgeLiensEmplacements:
		m.ResetLiensEmplacements()
		return nil
	case objet.EdgeChampsPersonnalises:
		m.ResetChampsPersonnalises()
		return nil
	case objet.EdgePiecesJointes:
		m.ResetPiecesJointes()
		return nil
	}
	return fmt.Errorf("unknown Objet edge %s", name)
}

// PieceJointeMutation represents an operation that mutates the PieceJointe nodes in the graph.
type PieceJointeMutation struct {
	config
	op             Op
	typ            string
	id             *uuid.UUID
	nom_fichier    *string
	chemin         *string
	type_mime      *string
	est_principale *bool
	categorie      *piecejointe.Categorie
	created_at     *time.Time
	updated_at     *time.Time
	clearedFields  map[string]struct{}
	objet          *uuid.UUID
	clearedobjet   bool
	done           bool
	oldValue       func(context.Context) (*PieceJointe, error)
	predicates     []predicate.PieceJointe
}

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

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

// newPieceJointeMutation creates new mutation for the PieceJointe entity.
func newPieceJointeMutation(c config, op Op, opts ...piecejointeOption) *PieceJointeMutation {
	m := &PieceJointeMutation{
		config:        c,
		op:            op,
		typ:           TypePieceJointe,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

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

// SetObjetID sets the "objet_id" field.
func (m *PieceJointeMutation) SetObjetID(u uuid.UUID) {
	m.objet = &u
}

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

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

// ResetObjetID resets all changes to the "objet_id" field.
func (m *PieceJointeMutation) ResetObjetID() {
	m.objet = nil
}

// SetNomFichier sets the "nom_fichier" field.
func (m *PieceJointeMutation) SetNomFichier(s string) {
	m.nom_fichier = &s
}

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

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

// ResetNomFichier resets all changes to the "nom_fichier" field.
func (m *PieceJointeMutation) ResetNomFichier() {
	m.nom_fichier = nil
}

// SetChemin sets the "chemin" field.
func (m *PieceJointeMutation) SetChemin(s string) {
	m.chemin = &s
}

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

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

// ResetChemin resets all changes to the "chemin" field.
func (m *PieceJointeMutation) ResetChemin() {
	m.chemin = nil
}

// SetTypeMime sets the "type_mime" field.
func (m *PieceJointeMutation) SetTypeMime(s string) {
	m.type_mime = &s
}

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

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

// ResetTypeMime resets all changes to the "type_mime" field.
func (m *PieceJointeMutation) ResetTypeMime() {
	m.type_mime = nil
}

// SetEstPrincipale sets the "est_principale" field.
func (m *PieceJointeMutation) SetEstPrincipale(b bool) {
	m.est_principale = &b
}

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

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

// ResetEstPrincipale resets all changes to the "est_principale" field.
func (m *PieceJointeMutation) ResetEstPrincipale() {
	m.est_principale = nil
}

// SetCategorie sets the "categorie" field.
func (m *PieceJointeMutation) SetCategorie(pi piecejointe.Categorie) {
	m.categorie = &pi
}

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

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

// ResetCategorie resets all changes to the "categorie" field.
func (m *PieceJointeMutation) ResetCategorie() {
	m.categorie = nil
}

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

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

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

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

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

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

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

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

// ClearObjet clears the "objet" edge to the Objet entity.
func (m *PieceJointeMutation) ClearObjet() {
	m.clearedobjet = true
	m.clearedFields[piecejointe.FieldObjetID] = struct{}{}
}

// ObjetCleared reports if the "objet" edge to the Objet entity was cleared.
func (m *PieceJointeMutation) ObjetCleared() bool {
	return m.clearedobjet
}

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

// ResetObjet resets all changes to the "objet" edge.
func (m *PieceJointeMutation) ResetObjet() {
	m.objet = nil
	m.clearedobjet = false
}

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

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

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

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

// Type returns the node type of this mutation (PieceJointe).
func (m *PieceJointeMutation) 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 *PieceJointeMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.objet != nil {
		fields = append(fields, piecejointe.FieldObjetID)
	}
	if m.nom_fichier != nil {
		fields = append(fields, piecejointe.FieldNomFichier)
	}
	if m.chemin != nil {
		fields = append(fields, piecejointe.FieldChemin)
	}
	if m.type_mime != nil {
		fields = append(fields, piecejointe.FieldTypeMime)
	}
	if m.est_principale != nil {
		fields = append(fields, piecejointe.FieldEstPrincipale)
	}
	if m.categorie != nil {
		fields = append(fields, piecejointe.FieldCategorie)
	}
	if m.created_at != nil {
		fields = append(fields, piecejointe.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, piecejointe.FieldUpdatedAt)
	}
	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 *PieceJointeMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case piecejointe.FieldObjetID:
		return m.ObjetID()
	case piecejointe.FieldNomFichier:
		return m.NomFichier()
	case piecejointe.FieldChemin:
		return m.Chemin()
	case piecejointe.FieldTypeMime:
		return m.TypeMime()
	case piecejointe.FieldEstPrincipale:
		return m.EstPrincipale()
	case piecejointe.FieldCategorie:
		return m.Categorie()
	case piecejointe.FieldCreatedAt:
		return m.CreatedAt()
	case piecejointe.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *PieceJointeMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case piecejointe.FieldObjetID:
		return m.OldObjetID(ctx)
	case piecejointe.FieldNomFichier:
		return m.OldNomFichier(ctx)
	case piecejointe.FieldChemin:
		return m.OldChemin(ctx)
	case piecejointe.FieldTypeMime:
		return m.OldTypeMime(ctx)
	case piecejointe.FieldEstPrincipale:
		return m.OldEstPrincipale(ctx)
	case piecejointe.FieldCategorie:
		return m.OldCategorie(ctx)
	case piecejointe.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case piecejointe.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown PieceJointe 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 *PieceJointeMutation) SetField(name string, value ent.Value) error {
	switch name {
	case piecejointe.FieldObjetID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetObjetID(v)
		return nil
	case piecejointe.FieldNomFichier:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNomFichier(v)
		return nil
	case piecejointe.FieldChemin:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChemin(v)
		return nil
	case piecejointe.FieldTypeMime:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTypeMime(v)
		return nil
	case piecejointe.FieldEstPrincipale:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEstPrincipale(v)
		return nil
	case piecejointe.FieldCategorie:
		v, ok := value.(piecejointe.Categorie)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCategorie(v)
		return nil
	case piecejointe.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case piecejointe.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown PieceJointe field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PieceJointeMutation) 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 *PieceJointeMutation) ClearField(name string) error {
	return fmt.Errorf("unknown PieceJointe 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 *PieceJointeMutation) ResetField(name string) error {
	switch name {
	case piecejointe.FieldObjetID:
		m.ResetObjetID()
		return nil
	case piecejointe.FieldNomFichier:
		m.ResetNomFichier()
		return nil
	case piecejointe.FieldChemin:
		m.ResetChemin()
		return nil
	case piecejointe.FieldTypeMime:
		m.ResetTypeMime()
		return nil
	case piecejointe.FieldEstPrincipale:
		m.ResetEstPrincipale()
		return nil
	case piecejointe.FieldCategorie:
		m.ResetCategorie()
		return nil
	case piecejointe.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case piecejointe.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown PieceJointe field %s", name)
}

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

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *PieceJointeMutation) EdgeCleared(name string) bool {
	switch name {
	case piecejointe.EdgeObjet:
		return m.clearedobjet
	}
	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 *PieceJointeMutation) ClearEdge(name string) error {
	switch name {
	case piecejointe.EdgeObjet:
		m.ClearObjet()
		return nil
	}
	return fmt.Errorf("unknown PieceJointe 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 *PieceJointeMutation) ResetEdge(name string) error {
	switch name {
	case piecejointe.EdgeObjet:
		m.ResetObjet()
		return nil
	}
	return fmt.Errorf("unknown PieceJointe edge %s", name)
}