// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"
	"wechat-api/ent/batchmsg"
	"wechat-api/ent/contact"
	"wechat-api/ent/custom_types"
	"wechat-api/ent/label"
	"wechat-api/ent/labelrelationship"
	"wechat-api/ent/message"
	"wechat-api/ent/messagerecords"
	"wechat-api/ent/predicate"
	"wechat-api/ent/server"
	"wechat-api/ent/sopnode"
	"wechat-api/ent/sopstage"
	"wechat-api/ent/soptask"
	"wechat-api/ent/wx"

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
)

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

	// Node types.
	TypeBatchMsg          = "BatchMsg"
	TypeContact           = "Contact"
	TypeLabel             = "Label"
	TypeLabelRelationship = "LabelRelationship"
	TypeMessage           = "Message"
	TypeMessageRecords    = "MessageRecords"
	TypeServer            = "Server"
	TypeSopNode           = "SopNode"
	TypeSopStage          = "SopStage"
	TypeSopTask           = "SopTask"
	TypeWx                = "Wx"
)

// BatchMsgMutation represents an operation that mutates the BatchMsg nodes in the graph.
type BatchMsgMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	status        *uint8
	addstatus     *int8
	batch_no      *string
	fromwxid      *string
	msg           *string
	tag           *string
	total         *int32
	addtotal      *int32
	success       *int32
	addsuccess    *int32
	fail          *int32
	addfail       *int32
	start_time    *time.Time
	stop_time     *time.Time
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*BatchMsg, error)
	predicates    []predicate.BatchMsg
}

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

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

// newBatchMsgMutation creates new mutation for the BatchMsg entity.
func newBatchMsgMutation(c config, op Op, opts ...batchmsgOption) *BatchMsgMutation {
	m := &BatchMsgMutation{
		config:        c,
		op:            op,
		typ:           TypeBatchMsg,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withBatchMsg sets the old BatchMsg of the mutation.
func withBatchMsg(node *BatchMsg) batchmsgOption {
	return func(m *BatchMsgMutation) {
		m.oldValue = func(context.Context) (*BatchMsg, 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 BatchMsgMutation) 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 BatchMsgMutation) 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 BatchMsg entities.
func (m *BatchMsgMutation) SetID(id uint64) {
	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 *BatchMsgMutation) ID() (id uint64, 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 *BatchMsgMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().BatchMsg.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *BatchMsgMutation) 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 BatchMsg entity.
// If the BatchMsg 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 *BatchMsgMutation) 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 *BatchMsgMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetDeletedAt sets the "deleted_at" field.
func (m *BatchMsgMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *BatchMsgMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[batchmsg.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *BatchMsgMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *BatchMsgMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, batchmsg.FieldDeletedAt)
}

// SetStatus sets the "status" field.
func (m *BatchMsgMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *BatchMsgMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[batchmsg.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *BatchMsgMutation) StatusCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *BatchMsgMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, batchmsg.FieldStatus)
}

// SetBatchNo sets the "batch_no" field.
func (m *BatchMsgMutation) SetBatchNo(s string) {
	m.batch_no = &s
}

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

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

// ClearBatchNo clears the value of the "batch_no" field.
func (m *BatchMsgMutation) ClearBatchNo() {
	m.batch_no = nil
	m.clearedFields[batchmsg.FieldBatchNo] = struct{}{}
}

// BatchNoCleared returns if the "batch_no" field was cleared in this mutation.
func (m *BatchMsgMutation) BatchNoCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldBatchNo]
	return ok
}

// ResetBatchNo resets all changes to the "batch_no" field.
func (m *BatchMsgMutation) ResetBatchNo() {
	m.batch_no = nil
	delete(m.clearedFields, batchmsg.FieldBatchNo)
}

// SetFromwxid sets the "fromwxid" field.
func (m *BatchMsgMutation) SetFromwxid(s string) {
	m.fromwxid = &s
}

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

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

// ClearFromwxid clears the value of the "fromwxid" field.
func (m *BatchMsgMutation) ClearFromwxid() {
	m.fromwxid = nil
	m.clearedFields[batchmsg.FieldFromwxid] = struct{}{}
}

// FromwxidCleared returns if the "fromwxid" field was cleared in this mutation.
func (m *BatchMsgMutation) FromwxidCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldFromwxid]
	return ok
}

// ResetFromwxid resets all changes to the "fromwxid" field.
func (m *BatchMsgMutation) ResetFromwxid() {
	m.fromwxid = nil
	delete(m.clearedFields, batchmsg.FieldFromwxid)
}

// SetMsg sets the "msg" field.
func (m *BatchMsgMutation) SetMsg(s string) {
	m.msg = &s
}

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

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

// ClearMsg clears the value of the "msg" field.
func (m *BatchMsgMutation) ClearMsg() {
	m.msg = nil
	m.clearedFields[batchmsg.FieldMsg] = struct{}{}
}

// MsgCleared returns if the "msg" field was cleared in this mutation.
func (m *BatchMsgMutation) MsgCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldMsg]
	return ok
}

// ResetMsg resets all changes to the "msg" field.
func (m *BatchMsgMutation) ResetMsg() {
	m.msg = nil
	delete(m.clearedFields, batchmsg.FieldMsg)
}

// SetTag sets the "tag" field.
func (m *BatchMsgMutation) SetTag(s string) {
	m.tag = &s
}

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

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

// ClearTag clears the value of the "tag" field.
func (m *BatchMsgMutation) ClearTag() {
	m.tag = nil
	m.clearedFields[batchmsg.FieldTag] = struct{}{}
}

// TagCleared returns if the "tag" field was cleared in this mutation.
func (m *BatchMsgMutation) TagCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldTag]
	return ok
}

// ResetTag resets all changes to the "tag" field.
func (m *BatchMsgMutation) ResetTag() {
	m.tag = nil
	delete(m.clearedFields, batchmsg.FieldTag)
}

// SetTotal sets the "total" field.
func (m *BatchMsgMutation) SetTotal(i int32) {
	m.total = &i
	m.addtotal = nil
}

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

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

// AddTotal adds i to the "total" field.
func (m *BatchMsgMutation) AddTotal(i int32) {
	if m.addtotal != nil {
		*m.addtotal += i
	} else {
		m.addtotal = &i
	}
}

// AddedTotal returns the value that was added to the "total" field in this mutation.
func (m *BatchMsgMutation) AddedTotal() (r int32, exists bool) {
	v := m.addtotal
	if v == nil {
		return
	}
	return *v, true
}

// ClearTotal clears the value of the "total" field.
func (m *BatchMsgMutation) ClearTotal() {
	m.total = nil
	m.addtotal = nil
	m.clearedFields[batchmsg.FieldTotal] = struct{}{}
}

// TotalCleared returns if the "total" field was cleared in this mutation.
func (m *BatchMsgMutation) TotalCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldTotal]
	return ok
}

// ResetTotal resets all changes to the "total" field.
func (m *BatchMsgMutation) ResetTotal() {
	m.total = nil
	m.addtotal = nil
	delete(m.clearedFields, batchmsg.FieldTotal)
}

// SetSuccess sets the "success" field.
func (m *BatchMsgMutation) SetSuccess(i int32) {
	m.success = &i
	m.addsuccess = nil
}

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

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

// AddSuccess adds i to the "success" field.
func (m *BatchMsgMutation) AddSuccess(i int32) {
	if m.addsuccess != nil {
		*m.addsuccess += i
	} else {
		m.addsuccess = &i
	}
}

// AddedSuccess returns the value that was added to the "success" field in this mutation.
func (m *BatchMsgMutation) AddedSuccess() (r int32, exists bool) {
	v := m.addsuccess
	if v == nil {
		return
	}
	return *v, true
}

// ClearSuccess clears the value of the "success" field.
func (m *BatchMsgMutation) ClearSuccess() {
	m.success = nil
	m.addsuccess = nil
	m.clearedFields[batchmsg.FieldSuccess] = struct{}{}
}

// SuccessCleared returns if the "success" field was cleared in this mutation.
func (m *BatchMsgMutation) SuccessCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldSuccess]
	return ok
}

// ResetSuccess resets all changes to the "success" field.
func (m *BatchMsgMutation) ResetSuccess() {
	m.success = nil
	m.addsuccess = nil
	delete(m.clearedFields, batchmsg.FieldSuccess)
}

// SetFail sets the "fail" field.
func (m *BatchMsgMutation) SetFail(i int32) {
	m.fail = &i
	m.addfail = nil
}

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

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

// AddFail adds i to the "fail" field.
func (m *BatchMsgMutation) AddFail(i int32) {
	if m.addfail != nil {
		*m.addfail += i
	} else {
		m.addfail = &i
	}
}

// AddedFail returns the value that was added to the "fail" field in this mutation.
func (m *BatchMsgMutation) AddedFail() (r int32, exists bool) {
	v := m.addfail
	if v == nil {
		return
	}
	return *v, true
}

// ClearFail clears the value of the "fail" field.
func (m *BatchMsgMutation) ClearFail() {
	m.fail = nil
	m.addfail = nil
	m.clearedFields[batchmsg.FieldFail] = struct{}{}
}

// FailCleared returns if the "fail" field was cleared in this mutation.
func (m *BatchMsgMutation) FailCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldFail]
	return ok
}

// ResetFail resets all changes to the "fail" field.
func (m *BatchMsgMutation) ResetFail() {
	m.fail = nil
	m.addfail = nil
	delete(m.clearedFields, batchmsg.FieldFail)
}

// SetStartTime sets the "start_time" field.
func (m *BatchMsgMutation) SetStartTime(t time.Time) {
	m.start_time = &t
}

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

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

// ClearStartTime clears the value of the "start_time" field.
func (m *BatchMsgMutation) ClearStartTime() {
	m.start_time = nil
	m.clearedFields[batchmsg.FieldStartTime] = struct{}{}
}

// StartTimeCleared returns if the "start_time" field was cleared in this mutation.
func (m *BatchMsgMutation) StartTimeCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldStartTime]
	return ok
}

// ResetStartTime resets all changes to the "start_time" field.
func (m *BatchMsgMutation) ResetStartTime() {
	m.start_time = nil
	delete(m.clearedFields, batchmsg.FieldStartTime)
}

// SetStopTime sets the "stop_time" field.
func (m *BatchMsgMutation) SetStopTime(t time.Time) {
	m.stop_time = &t
}

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

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

// ClearStopTime clears the value of the "stop_time" field.
func (m *BatchMsgMutation) ClearStopTime() {
	m.stop_time = nil
	m.clearedFields[batchmsg.FieldStopTime] = struct{}{}
}

// StopTimeCleared returns if the "stop_time" field was cleared in this mutation.
func (m *BatchMsgMutation) StopTimeCleared() bool {
	_, ok := m.clearedFields[batchmsg.FieldStopTime]
	return ok
}

// ResetStopTime resets all changes to the "stop_time" field.
func (m *BatchMsgMutation) ResetStopTime() {
	m.stop_time = nil
	delete(m.clearedFields, batchmsg.FieldStopTime)
}

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

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

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

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

// Type returns the node type of this mutation (BatchMsg).
func (m *BatchMsgMutation) 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 *BatchMsgMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.created_at != nil {
		fields = append(fields, batchmsg.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, batchmsg.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, batchmsg.FieldDeletedAt)
	}
	if m.status != nil {
		fields = append(fields, batchmsg.FieldStatus)
	}
	if m.batch_no != nil {
		fields = append(fields, batchmsg.FieldBatchNo)
	}
	if m.fromwxid != nil {
		fields = append(fields, batchmsg.FieldFromwxid)
	}
	if m.msg != nil {
		fields = append(fields, batchmsg.FieldMsg)
	}
	if m.tag != nil {
		fields = append(fields, batchmsg.FieldTag)
	}
	if m.total != nil {
		fields = append(fields, batchmsg.FieldTotal)
	}
	if m.success != nil {
		fields = append(fields, batchmsg.FieldSuccess)
	}
	if m.fail != nil {
		fields = append(fields, batchmsg.FieldFail)
	}
	if m.start_time != nil {
		fields = append(fields, batchmsg.FieldStartTime)
	}
	if m.stop_time != nil {
		fields = append(fields, batchmsg.FieldStopTime)
	}
	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 *BatchMsgMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case batchmsg.FieldCreatedAt:
		return m.CreatedAt()
	case batchmsg.FieldUpdatedAt:
		return m.UpdatedAt()
	case batchmsg.FieldDeletedAt:
		return m.DeletedAt()
	case batchmsg.FieldStatus:
		return m.Status()
	case batchmsg.FieldBatchNo:
		return m.BatchNo()
	case batchmsg.FieldFromwxid:
		return m.Fromwxid()
	case batchmsg.FieldMsg:
		return m.Msg()
	case batchmsg.FieldTag:
		return m.Tag()
	case batchmsg.FieldTotal:
		return m.Total()
	case batchmsg.FieldSuccess:
		return m.Success()
	case batchmsg.FieldFail:
		return m.Fail()
	case batchmsg.FieldStartTime:
		return m.StartTime()
	case batchmsg.FieldStopTime:
		return m.StopTime()
	}
	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 *BatchMsgMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case batchmsg.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case batchmsg.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case batchmsg.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case batchmsg.FieldStatus:
		return m.OldStatus(ctx)
	case batchmsg.FieldBatchNo:
		return m.OldBatchNo(ctx)
	case batchmsg.FieldFromwxid:
		return m.OldFromwxid(ctx)
	case batchmsg.FieldMsg:
		return m.OldMsg(ctx)
	case batchmsg.FieldTag:
		return m.OldTag(ctx)
	case batchmsg.FieldTotal:
		return m.OldTotal(ctx)
	case batchmsg.FieldSuccess:
		return m.OldSuccess(ctx)
	case batchmsg.FieldFail:
		return m.OldFail(ctx)
	case batchmsg.FieldStartTime:
		return m.OldStartTime(ctx)
	case batchmsg.FieldStopTime:
		return m.OldStopTime(ctx)
	}
	return nil, fmt.Errorf("unknown BatchMsg 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 *BatchMsgMutation) SetField(name string, value ent.Value) error {
	switch name {
	case batchmsg.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 batchmsg.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case batchmsg.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case batchmsg.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case batchmsg.FieldBatchNo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBatchNo(v)
		return nil
	case batchmsg.FieldFromwxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFromwxid(v)
		return nil
	case batchmsg.FieldMsg:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMsg(v)
		return nil
	case batchmsg.FieldTag:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTag(v)
		return nil
	case batchmsg.FieldTotal:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotal(v)
		return nil
	case batchmsg.FieldSuccess:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSuccess(v)
		return nil
	case batchmsg.FieldFail:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFail(v)
		return nil
	case batchmsg.FieldStartTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartTime(v)
		return nil
	case batchmsg.FieldStopTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStopTime(v)
		return nil
	}
	return fmt.Errorf("unknown BatchMsg field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *BatchMsgMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, batchmsg.FieldStatus)
	}
	if m.addtotal != nil {
		fields = append(fields, batchmsg.FieldTotal)
	}
	if m.addsuccess != nil {
		fields = append(fields, batchmsg.FieldSuccess)
	}
	if m.addfail != nil {
		fields = append(fields, batchmsg.FieldFail)
	}
	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 *BatchMsgMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case batchmsg.FieldStatus:
		return m.AddedStatus()
	case batchmsg.FieldTotal:
		return m.AddedTotal()
	case batchmsg.FieldSuccess:
		return m.AddedSuccess()
	case batchmsg.FieldFail:
		return m.AddedFail()
	}
	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 *BatchMsgMutation) AddField(name string, value ent.Value) error {
	switch name {
	case batchmsg.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case batchmsg.FieldTotal:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotal(v)
		return nil
	case batchmsg.FieldSuccess:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSuccess(v)
		return nil
	case batchmsg.FieldFail:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddFail(v)
		return nil
	}
	return fmt.Errorf("unknown BatchMsg numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *BatchMsgMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(batchmsg.FieldDeletedAt) {
		fields = append(fields, batchmsg.FieldDeletedAt)
	}
	if m.FieldCleared(batchmsg.FieldStatus) {
		fields = append(fields, batchmsg.FieldStatus)
	}
	if m.FieldCleared(batchmsg.FieldBatchNo) {
		fields = append(fields, batchmsg.FieldBatchNo)
	}
	if m.FieldCleared(batchmsg.FieldFromwxid) {
		fields = append(fields, batchmsg.FieldFromwxid)
	}
	if m.FieldCleared(batchmsg.FieldMsg) {
		fields = append(fields, batchmsg.FieldMsg)
	}
	if m.FieldCleared(batchmsg.FieldTag) {
		fields = append(fields, batchmsg.FieldTag)
	}
	if m.FieldCleared(batchmsg.FieldTotal) {
		fields = append(fields, batchmsg.FieldTotal)
	}
	if m.FieldCleared(batchmsg.FieldSuccess) {
		fields = append(fields, batchmsg.FieldSuccess)
	}
	if m.FieldCleared(batchmsg.FieldFail) {
		fields = append(fields, batchmsg.FieldFail)
	}
	if m.FieldCleared(batchmsg.FieldStartTime) {
		fields = append(fields, batchmsg.FieldStartTime)
	}
	if m.FieldCleared(batchmsg.FieldStopTime) {
		fields = append(fields, batchmsg.FieldStopTime)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *BatchMsgMutation) 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 *BatchMsgMutation) ClearField(name string) error {
	switch name {
	case batchmsg.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case batchmsg.FieldStatus:
		m.ClearStatus()
		return nil
	case batchmsg.FieldBatchNo:
		m.ClearBatchNo()
		return nil
	case batchmsg.FieldFromwxid:
		m.ClearFromwxid()
		return nil
	case batchmsg.FieldMsg:
		m.ClearMsg()
		return nil
	case batchmsg.FieldTag:
		m.ClearTag()
		return nil
	case batchmsg.FieldTotal:
		m.ClearTotal()
		return nil
	case batchmsg.FieldSuccess:
		m.ClearSuccess()
		return nil
	case batchmsg.FieldFail:
		m.ClearFail()
		return nil
	case batchmsg.FieldStartTime:
		m.ClearStartTime()
		return nil
	case batchmsg.FieldStopTime:
		m.ClearStopTime()
		return nil
	}
	return fmt.Errorf("unknown BatchMsg 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 *BatchMsgMutation) ResetField(name string) error {
	switch name {
	case batchmsg.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case batchmsg.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case batchmsg.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case batchmsg.FieldStatus:
		m.ResetStatus()
		return nil
	case batchmsg.FieldBatchNo:
		m.ResetBatchNo()
		return nil
	case batchmsg.FieldFromwxid:
		m.ResetFromwxid()
		return nil
	case batchmsg.FieldMsg:
		m.ResetMsg()
		return nil
	case batchmsg.FieldTag:
		m.ResetTag()
		return nil
	case batchmsg.FieldTotal:
		m.ResetTotal()
		return nil
	case batchmsg.FieldSuccess:
		m.ResetSuccess()
		return nil
	case batchmsg.FieldFail:
		m.ResetFail()
		return nil
	case batchmsg.FieldStartTime:
		m.ResetStartTime()
		return nil
	case batchmsg.FieldStopTime:
		m.ResetStopTime()
		return nil
	}
	return fmt.Errorf("unknown BatchMsg field %s", name)
}

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

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

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

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

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

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

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

// ContactMutation represents an operation that mutates the Contact nodes in the graph.
type ContactMutation struct {
	config
	op                           Op
	typ                          string
	id                           *uint64
	created_at                   *time.Time
	updated_at                   *time.Time
	status                       *uint8
	addstatus                    *int8
	deleted_at                   *time.Time
	wx_wxid                      *string
	_type                        *int
	add_type                     *int
	wxid                         *string
	account                      *string
	nickname                     *string
	markname                     *string
	headimg                      *string
	sex                          *int
	addsex                       *int
	starrole                     *string
	dontseeit                    *int
	adddontseeit                 *int
	dontseeme                    *int
	adddontseeme                 *int
	lag                          *string
	gid                          *string
	gname                        *string
	v3                           *string
	clearedFields                map[string]struct{}
	contact_relationships        map[uint64]struct{}
	removedcontact_relationships map[uint64]struct{}
	clearedcontact_relationships bool
	contact_messages             map[uint64]struct{}
	removedcontact_messages      map[uint64]struct{}
	clearedcontact_messages      bool
	done                         bool
	oldValue                     func(context.Context) (*Contact, error)
	predicates                   []predicate.Contact
}

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

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

// newContactMutation creates new mutation for the Contact entity.
func newContactMutation(c config, op Op, opts ...contactOption) *ContactMutation {
	m := &ContactMutation{
		config:        c,
		op:            op,
		typ:           TypeContact,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withContact sets the old Contact of the mutation.
func withContact(node *Contact) contactOption {
	return func(m *ContactMutation) {
		m.oldValue = func(context.Context) (*Contact, 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 ContactMutation) 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 ContactMutation) 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 Contact entities.
func (m *ContactMutation) SetID(id uint64) {
	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 *ContactMutation) ID() (id uint64, 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 *ContactMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Contact.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *ContactMutation) 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 Contact entity.
// If the Contact 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 *ContactMutation) 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 *ContactMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *ContactMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *ContactMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[contact.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *ContactMutation) StatusCleared() bool {
	_, ok := m.clearedFields[contact.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *ContactMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, contact.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *ContactMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *ContactMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[contact.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *ContactMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[contact.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *ContactMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, contact.FieldDeletedAt)
}

// SetWxWxid sets the "wx_wxid" field.
func (m *ContactMutation) SetWxWxid(s string) {
	m.wx_wxid = &s
}

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

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

// ClearWxWxid clears the value of the "wx_wxid" field.
func (m *ContactMutation) ClearWxWxid() {
	m.wx_wxid = nil
	m.clearedFields[contact.FieldWxWxid] = struct{}{}
}

// WxWxidCleared returns if the "wx_wxid" field was cleared in this mutation.
func (m *ContactMutation) WxWxidCleared() bool {
	_, ok := m.clearedFields[contact.FieldWxWxid]
	return ok
}

// ResetWxWxid resets all changes to the "wx_wxid" field.
func (m *ContactMutation) ResetWxWxid() {
	m.wx_wxid = nil
	delete(m.clearedFields, contact.FieldWxWxid)
}

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

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

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

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

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

// ClearType clears the value of the "type" field.
func (m *ContactMutation) ClearType() {
	m._type = nil
	m.add_type = nil
	m.clearedFields[contact.FieldType] = struct{}{}
}

// TypeCleared returns if the "type" field was cleared in this mutation.
func (m *ContactMutation) TypeCleared() bool {
	_, ok := m.clearedFields[contact.FieldType]
	return ok
}

// ResetType resets all changes to the "type" field.
func (m *ContactMutation) ResetType() {
	m._type = nil
	m.add_type = nil
	delete(m.clearedFields, contact.FieldType)
}

// SetWxid sets the "wxid" field.
func (m *ContactMutation) SetWxid(s string) {
	m.wxid = &s
}

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

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

// ResetWxid resets all changes to the "wxid" field.
func (m *ContactMutation) ResetWxid() {
	m.wxid = nil
}

// SetAccount sets the "account" field.
func (m *ContactMutation) SetAccount(s string) {
	m.account = &s
}

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

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

// ResetAccount resets all changes to the "account" field.
func (m *ContactMutation) ResetAccount() {
	m.account = nil
}

// SetNickname sets the "nickname" field.
func (m *ContactMutation) SetNickname(s string) {
	m.nickname = &s
}

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

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

// ResetNickname resets all changes to the "nickname" field.
func (m *ContactMutation) ResetNickname() {
	m.nickname = nil
}

// SetMarkname sets the "markname" field.
func (m *ContactMutation) SetMarkname(s string) {
	m.markname = &s
}

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

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

// ResetMarkname resets all changes to the "markname" field.
func (m *ContactMutation) ResetMarkname() {
	m.markname = nil
}

// SetHeadimg sets the "headimg" field.
func (m *ContactMutation) SetHeadimg(s string) {
	m.headimg = &s
}

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

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

// ResetHeadimg resets all changes to the "headimg" field.
func (m *ContactMutation) ResetHeadimg() {
	m.headimg = nil
}

// SetSex sets the "sex" field.
func (m *ContactMutation) SetSex(i int) {
	m.sex = &i
	m.addsex = nil
}

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

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

// AddSex adds i to the "sex" field.
func (m *ContactMutation) AddSex(i int) {
	if m.addsex != nil {
		*m.addsex += i
	} else {
		m.addsex = &i
	}
}

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

// ResetSex resets all changes to the "sex" field.
func (m *ContactMutation) ResetSex() {
	m.sex = nil
	m.addsex = nil
}

// SetStarrole sets the "starrole" field.
func (m *ContactMutation) SetStarrole(s string) {
	m.starrole = &s
}

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

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

// ResetStarrole resets all changes to the "starrole" field.
func (m *ContactMutation) ResetStarrole() {
	m.starrole = nil
}

// SetDontseeit sets the "dontseeit" field.
func (m *ContactMutation) SetDontseeit(i int) {
	m.dontseeit = &i
	m.adddontseeit = nil
}

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

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

// AddDontseeit adds i to the "dontseeit" field.
func (m *ContactMutation) AddDontseeit(i int) {
	if m.adddontseeit != nil {
		*m.adddontseeit += i
	} else {
		m.adddontseeit = &i
	}
}

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

// ResetDontseeit resets all changes to the "dontseeit" field.
func (m *ContactMutation) ResetDontseeit() {
	m.dontseeit = nil
	m.adddontseeit = nil
}

// SetDontseeme sets the "dontseeme" field.
func (m *ContactMutation) SetDontseeme(i int) {
	m.dontseeme = &i
	m.adddontseeme = nil
}

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

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

// AddDontseeme adds i to the "dontseeme" field.
func (m *ContactMutation) AddDontseeme(i int) {
	if m.adddontseeme != nil {
		*m.adddontseeme += i
	} else {
		m.adddontseeme = &i
	}
}

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

// ResetDontseeme resets all changes to the "dontseeme" field.
func (m *ContactMutation) ResetDontseeme() {
	m.dontseeme = nil
	m.adddontseeme = nil
}

// SetLag sets the "lag" field.
func (m *ContactMutation) SetLag(s string) {
	m.lag = &s
}

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

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

// ResetLag resets all changes to the "lag" field.
func (m *ContactMutation) ResetLag() {
	m.lag = nil
}

// SetGid sets the "gid" field.
func (m *ContactMutation) SetGid(s string) {
	m.gid = &s
}

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

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

// ResetGid resets all changes to the "gid" field.
func (m *ContactMutation) ResetGid() {
	m.gid = nil
}

// SetGname sets the "gname" field.
func (m *ContactMutation) SetGname(s string) {
	m.gname = &s
}

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

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

// ResetGname resets all changes to the "gname" field.
func (m *ContactMutation) ResetGname() {
	m.gname = nil
}

// SetV3 sets the "v3" field.
func (m *ContactMutation) SetV3(s string) {
	m.v3 = &s
}

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

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

// ResetV3 resets all changes to the "v3" field.
func (m *ContactMutation) ResetV3() {
	m.v3 = nil
}

// AddContactRelationshipIDs adds the "contact_relationships" edge to the LabelRelationship entity by ids.
func (m *ContactMutation) AddContactRelationshipIDs(ids ...uint64) {
	if m.contact_relationships == nil {
		m.contact_relationships = make(map[uint64]struct{})
	}
	for i := range ids {
		m.contact_relationships[ids[i]] = struct{}{}
	}
}

// ClearContactRelationships clears the "contact_relationships" edge to the LabelRelationship entity.
func (m *ContactMutation) ClearContactRelationships() {
	m.clearedcontact_relationships = true
}

// ContactRelationshipsCleared reports if the "contact_relationships" edge to the LabelRelationship entity was cleared.
func (m *ContactMutation) ContactRelationshipsCleared() bool {
	return m.clearedcontact_relationships
}

// RemoveContactRelationshipIDs removes the "contact_relationships" edge to the LabelRelationship entity by IDs.
func (m *ContactMutation) RemoveContactRelationshipIDs(ids ...uint64) {
	if m.removedcontact_relationships == nil {
		m.removedcontact_relationships = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.contact_relationships, ids[i])
		m.removedcontact_relationships[ids[i]] = struct{}{}
	}
}

// RemovedContactRelationships returns the removed IDs of the "contact_relationships" edge to the LabelRelationship entity.
func (m *ContactMutation) RemovedContactRelationshipsIDs() (ids []uint64) {
	for id := range m.removedcontact_relationships {
		ids = append(ids, id)
	}
	return
}

// ContactRelationshipsIDs returns the "contact_relationships" edge IDs in the mutation.
func (m *ContactMutation) ContactRelationshipsIDs() (ids []uint64) {
	for id := range m.contact_relationships {
		ids = append(ids, id)
	}
	return
}

// ResetContactRelationships resets all changes to the "contact_relationships" edge.
func (m *ContactMutation) ResetContactRelationships() {
	m.contact_relationships = nil
	m.clearedcontact_relationships = false
	m.removedcontact_relationships = nil
}

// AddContactMessageIDs adds the "contact_messages" edge to the MessageRecords entity by ids.
func (m *ContactMutation) AddContactMessageIDs(ids ...uint64) {
	if m.contact_messages == nil {
		m.contact_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		m.contact_messages[ids[i]] = struct{}{}
	}
}

// ClearContactMessages clears the "contact_messages" edge to the MessageRecords entity.
func (m *ContactMutation) ClearContactMessages() {
	m.clearedcontact_messages = true
}

// ContactMessagesCleared reports if the "contact_messages" edge to the MessageRecords entity was cleared.
func (m *ContactMutation) ContactMessagesCleared() bool {
	return m.clearedcontact_messages
}

// RemoveContactMessageIDs removes the "contact_messages" edge to the MessageRecords entity by IDs.
func (m *ContactMutation) RemoveContactMessageIDs(ids ...uint64) {
	if m.removedcontact_messages == nil {
		m.removedcontact_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.contact_messages, ids[i])
		m.removedcontact_messages[ids[i]] = struct{}{}
	}
}

// RemovedContactMessages returns the removed IDs of the "contact_messages" edge to the MessageRecords entity.
func (m *ContactMutation) RemovedContactMessagesIDs() (ids []uint64) {
	for id := range m.removedcontact_messages {
		ids = append(ids, id)
	}
	return
}

// ContactMessagesIDs returns the "contact_messages" edge IDs in the mutation.
func (m *ContactMutation) ContactMessagesIDs() (ids []uint64) {
	for id := range m.contact_messages {
		ids = append(ids, id)
	}
	return
}

// ResetContactMessages resets all changes to the "contact_messages" edge.
func (m *ContactMutation) ResetContactMessages() {
	m.contact_messages = nil
	m.clearedcontact_messages = false
	m.removedcontact_messages = nil
}

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

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

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

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

// Type returns the node type of this mutation (Contact).
func (m *ContactMutation) 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 *ContactMutation) Fields() []string {
	fields := make([]string, 0, 19)
	if m.created_at != nil {
		fields = append(fields, contact.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, contact.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, contact.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, contact.FieldDeletedAt)
	}
	if m.wx_wxid != nil {
		fields = append(fields, contact.FieldWxWxid)
	}
	if m._type != nil {
		fields = append(fields, contact.FieldType)
	}
	if m.wxid != nil {
		fields = append(fields, contact.FieldWxid)
	}
	if m.account != nil {
		fields = append(fields, contact.FieldAccount)
	}
	if m.nickname != nil {
		fields = append(fields, contact.FieldNickname)
	}
	if m.markname != nil {
		fields = append(fields, contact.FieldMarkname)
	}
	if m.headimg != nil {
		fields = append(fields, contact.FieldHeadimg)
	}
	if m.sex != nil {
		fields = append(fields, contact.FieldSex)
	}
	if m.starrole != nil {
		fields = append(fields, contact.FieldStarrole)
	}
	if m.dontseeit != nil {
		fields = append(fields, contact.FieldDontseeit)
	}
	if m.dontseeme != nil {
		fields = append(fields, contact.FieldDontseeme)
	}
	if m.lag != nil {
		fields = append(fields, contact.FieldLag)
	}
	if m.gid != nil {
		fields = append(fields, contact.FieldGid)
	}
	if m.gname != nil {
		fields = append(fields, contact.FieldGname)
	}
	if m.v3 != nil {
		fields = append(fields, contact.FieldV3)
	}
	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 *ContactMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case contact.FieldCreatedAt:
		return m.CreatedAt()
	case contact.FieldUpdatedAt:
		return m.UpdatedAt()
	case contact.FieldStatus:
		return m.Status()
	case contact.FieldDeletedAt:
		return m.DeletedAt()
	case contact.FieldWxWxid:
		return m.WxWxid()
	case contact.FieldType:
		return m.GetType()
	case contact.FieldWxid:
		return m.Wxid()
	case contact.FieldAccount:
		return m.Account()
	case contact.FieldNickname:
		return m.Nickname()
	case contact.FieldMarkname:
		return m.Markname()
	case contact.FieldHeadimg:
		return m.Headimg()
	case contact.FieldSex:
		return m.Sex()
	case contact.FieldStarrole:
		return m.Starrole()
	case contact.FieldDontseeit:
		return m.Dontseeit()
	case contact.FieldDontseeme:
		return m.Dontseeme()
	case contact.FieldLag:
		return m.Lag()
	case contact.FieldGid:
		return m.Gid()
	case contact.FieldGname:
		return m.Gname()
	case contact.FieldV3:
		return m.V3()
	}
	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 *ContactMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case contact.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case contact.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case contact.FieldStatus:
		return m.OldStatus(ctx)
	case contact.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case contact.FieldWxWxid:
		return m.OldWxWxid(ctx)
	case contact.FieldType:
		return m.OldType(ctx)
	case contact.FieldWxid:
		return m.OldWxid(ctx)
	case contact.FieldAccount:
		return m.OldAccount(ctx)
	case contact.FieldNickname:
		return m.OldNickname(ctx)
	case contact.FieldMarkname:
		return m.OldMarkname(ctx)
	case contact.FieldHeadimg:
		return m.OldHeadimg(ctx)
	case contact.FieldSex:
		return m.OldSex(ctx)
	case contact.FieldStarrole:
		return m.OldStarrole(ctx)
	case contact.FieldDontseeit:
		return m.OldDontseeit(ctx)
	case contact.FieldDontseeme:
		return m.OldDontseeme(ctx)
	case contact.FieldLag:
		return m.OldLag(ctx)
	case contact.FieldGid:
		return m.OldGid(ctx)
	case contact.FieldGname:
		return m.OldGname(ctx)
	case contact.FieldV3:
		return m.OldV3(ctx)
	}
	return nil, fmt.Errorf("unknown Contact 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 *ContactMutation) SetField(name string, value ent.Value) error {
	switch name {
	case contact.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 contact.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case contact.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case contact.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case contact.FieldWxWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxWxid(v)
		return nil
	case contact.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case contact.FieldWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxid(v)
		return nil
	case contact.FieldAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccount(v)
		return nil
	case contact.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case contact.FieldMarkname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarkname(v)
		return nil
	case contact.FieldHeadimg:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHeadimg(v)
		return nil
	case contact.FieldSex:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSex(v)
		return nil
	case contact.FieldStarrole:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStarrole(v)
		return nil
	case contact.FieldDontseeit:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDontseeit(v)
		return nil
	case contact.FieldDontseeme:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDontseeme(v)
		return nil
	case contact.FieldLag:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLag(v)
		return nil
	case contact.FieldGid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGid(v)
		return nil
	case contact.FieldGname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGname(v)
		return nil
	case contact.FieldV3:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetV3(v)
		return nil
	}
	return fmt.Errorf("unknown Contact field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ContactMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, contact.FieldStatus)
	}
	if m.add_type != nil {
		fields = append(fields, contact.FieldType)
	}
	if m.addsex != nil {
		fields = append(fields, contact.FieldSex)
	}
	if m.adddontseeit != nil {
		fields = append(fields, contact.FieldDontseeit)
	}
	if m.adddontseeme != nil {
		fields = append(fields, contact.FieldDontseeme)
	}
	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 *ContactMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case contact.FieldStatus:
		return m.AddedStatus()
	case contact.FieldType:
		return m.AddedType()
	case contact.FieldSex:
		return m.AddedSex()
	case contact.FieldDontseeit:
		return m.AddedDontseeit()
	case contact.FieldDontseeme:
		return m.AddedDontseeme()
	}
	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 *ContactMutation) AddField(name string, value ent.Value) error {
	switch name {
	case contact.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case contact.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case contact.FieldSex:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSex(v)
		return nil
	case contact.FieldDontseeit:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDontseeit(v)
		return nil
	case contact.FieldDontseeme:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDontseeme(v)
		return nil
	}
	return fmt.Errorf("unknown Contact numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ContactMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(contact.FieldStatus) {
		fields = append(fields, contact.FieldStatus)
	}
	if m.FieldCleared(contact.FieldDeletedAt) {
		fields = append(fields, contact.FieldDeletedAt)
	}
	if m.FieldCleared(contact.FieldWxWxid) {
		fields = append(fields, contact.FieldWxWxid)
	}
	if m.FieldCleared(contact.FieldType) {
		fields = append(fields, contact.FieldType)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ContactMutation) 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 *ContactMutation) ClearField(name string) error {
	switch name {
	case contact.FieldStatus:
		m.ClearStatus()
		return nil
	case contact.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case contact.FieldWxWxid:
		m.ClearWxWxid()
		return nil
	case contact.FieldType:
		m.ClearType()
		return nil
	}
	return fmt.Errorf("unknown Contact 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 *ContactMutation) ResetField(name string) error {
	switch name {
	case contact.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case contact.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case contact.FieldStatus:
		m.ResetStatus()
		return nil
	case contact.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case contact.FieldWxWxid:
		m.ResetWxWxid()
		return nil
	case contact.FieldType:
		m.ResetType()
		return nil
	case contact.FieldWxid:
		m.ResetWxid()
		return nil
	case contact.FieldAccount:
		m.ResetAccount()
		return nil
	case contact.FieldNickname:
		m.ResetNickname()
		return nil
	case contact.FieldMarkname:
		m.ResetMarkname()
		return nil
	case contact.FieldHeadimg:
		m.ResetHeadimg()
		return nil
	case contact.FieldSex:
		m.ResetSex()
		return nil
	case contact.FieldStarrole:
		m.ResetStarrole()
		return nil
	case contact.FieldDontseeit:
		m.ResetDontseeit()
		return nil
	case contact.FieldDontseeme:
		m.ResetDontseeme()
		return nil
	case contact.FieldLag:
		m.ResetLag()
		return nil
	case contact.FieldGid:
		m.ResetGid()
		return nil
	case contact.FieldGname:
		m.ResetGname()
		return nil
	case contact.FieldV3:
		m.ResetV3()
		return nil
	}
	return fmt.Errorf("unknown Contact field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *ContactMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.contact_relationships != nil {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.contact_messages != nil {
		edges = append(edges, contact.EdgeContactMessages)
	}
	return edges
}

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

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *ContactMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedcontact_relationships != nil {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.removedcontact_messages != nil {
		edges = append(edges, contact.EdgeContactMessages)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ContactMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedcontact_relationships {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.clearedcontact_messages {
		edges = append(edges, contact.EdgeContactMessages)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ContactMutation) EdgeCleared(name string) bool {
	switch name {
	case contact.EdgeContactRelationships:
		return m.clearedcontact_relationships
	case contact.EdgeContactMessages:
		return m.clearedcontact_messages
	}
	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 *ContactMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Contact 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 *ContactMutation) ResetEdge(name string) error {
	switch name {
	case contact.EdgeContactRelationships:
		m.ResetContactRelationships()
		return nil
	case contact.EdgeContactMessages:
		m.ResetContactMessages()
		return nil
	}
	return fmt.Errorf("unknown Contact edge %s", name)
}

// LabelMutation represents an operation that mutates the Label nodes in the graph.
type LabelMutation struct {
	config
	op                         Op
	typ                        string
	id                         *uint64
	created_at                 *time.Time
	updated_at                 *time.Time
	status                     *uint8
	addstatus                  *int8
	deleted_at                 *time.Time
	_type                      *int
	add_type                   *int
	name                       *string
	from                       *int
	addfrom                    *int
	mode                       *int
	addmode                    *int
	conditions                 *string
	clearedFields              map[string]struct{}
	label_relationships        map[uint64]struct{}
	removedlabel_relationships map[uint64]struct{}
	clearedlabel_relationships bool
	done                       bool
	oldValue                   func(context.Context) (*Label, error)
	predicates                 []predicate.Label
}

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

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

// newLabelMutation creates new mutation for the Label entity.
func newLabelMutation(c config, op Op, opts ...labelOption) *LabelMutation {
	m := &LabelMutation{
		config:        c,
		op:            op,
		typ:           TypeLabel,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withLabel sets the old Label of the mutation.
func withLabel(node *Label) labelOption {
	return func(m *LabelMutation) {
		m.oldValue = func(context.Context) (*Label, 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 LabelMutation) 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 LabelMutation) 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 Label entities.
func (m *LabelMutation) SetID(id uint64) {
	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 *LabelMutation) ID() (id uint64, 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 *LabelMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Label.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *LabelMutation) 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 Label entity.
// If the Label 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 *LabelMutation) 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 *LabelMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *LabelMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *LabelMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[label.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *LabelMutation) StatusCleared() bool {
	_, ok := m.clearedFields[label.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *LabelMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, label.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *LabelMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *LabelMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[label.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *LabelMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[label.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *LabelMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, label.FieldDeletedAt)
}

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

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

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

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

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

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

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

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

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

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

// SetFrom sets the "from" field.
func (m *LabelMutation) SetFrom(i int) {
	m.from = &i
	m.addfrom = nil
}

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

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

// AddFrom adds i to the "from" field.
func (m *LabelMutation) AddFrom(i int) {
	if m.addfrom != nil {
		*m.addfrom += i
	} else {
		m.addfrom = &i
	}
}

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

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

// SetMode sets the "mode" field.
func (m *LabelMutation) SetMode(i int) {
	m.mode = &i
	m.addmode = nil
}

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

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

// AddMode adds i to the "mode" field.
func (m *LabelMutation) AddMode(i int) {
	if m.addmode != nil {
		*m.addmode += i
	} else {
		m.addmode = &i
	}
}

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

// ResetMode resets all changes to the "mode" field.
func (m *LabelMutation) ResetMode() {
	m.mode = nil
	m.addmode = nil
}

// SetConditions sets the "conditions" field.
func (m *LabelMutation) SetConditions(s string) {
	m.conditions = &s
}

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

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

// ClearConditions clears the value of the "conditions" field.
func (m *LabelMutation) ClearConditions() {
	m.conditions = nil
	m.clearedFields[label.FieldConditions] = struct{}{}
}

// ConditionsCleared returns if the "conditions" field was cleared in this mutation.
func (m *LabelMutation) ConditionsCleared() bool {
	_, ok := m.clearedFields[label.FieldConditions]
	return ok
}

// ResetConditions resets all changes to the "conditions" field.
func (m *LabelMutation) ResetConditions() {
	m.conditions = nil
	delete(m.clearedFields, label.FieldConditions)
}

// AddLabelRelationshipIDs adds the "label_relationships" edge to the LabelRelationship entity by ids.
func (m *LabelMutation) AddLabelRelationshipIDs(ids ...uint64) {
	if m.label_relationships == nil {
		m.label_relationships = make(map[uint64]struct{})
	}
	for i := range ids {
		m.label_relationships[ids[i]] = struct{}{}
	}
}

// ClearLabelRelationships clears the "label_relationships" edge to the LabelRelationship entity.
func (m *LabelMutation) ClearLabelRelationships() {
	m.clearedlabel_relationships = true
}

// LabelRelationshipsCleared reports if the "label_relationships" edge to the LabelRelationship entity was cleared.
func (m *LabelMutation) LabelRelationshipsCleared() bool {
	return m.clearedlabel_relationships
}

// RemoveLabelRelationshipIDs removes the "label_relationships" edge to the LabelRelationship entity by IDs.
func (m *LabelMutation) RemoveLabelRelationshipIDs(ids ...uint64) {
	if m.removedlabel_relationships == nil {
		m.removedlabel_relationships = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.label_relationships, ids[i])
		m.removedlabel_relationships[ids[i]] = struct{}{}
	}
}

// RemovedLabelRelationships returns the removed IDs of the "label_relationships" edge to the LabelRelationship entity.
func (m *LabelMutation) RemovedLabelRelationshipsIDs() (ids []uint64) {
	for id := range m.removedlabel_relationships {
		ids = append(ids, id)
	}
	return
}

// LabelRelationshipsIDs returns the "label_relationships" edge IDs in the mutation.
func (m *LabelMutation) LabelRelationshipsIDs() (ids []uint64) {
	for id := range m.label_relationships {
		ids = append(ids, id)
	}
	return
}

// ResetLabelRelationships resets all changes to the "label_relationships" edge.
func (m *LabelMutation) ResetLabelRelationships() {
	m.label_relationships = nil
	m.clearedlabel_relationships = false
	m.removedlabel_relationships = nil
}

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

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

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

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

// Type returns the node type of this mutation (Label).
func (m *LabelMutation) 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 *LabelMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, label.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, label.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, label.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, label.FieldDeletedAt)
	}
	if m._type != nil {
		fields = append(fields, label.FieldType)
	}
	if m.name != nil {
		fields = append(fields, label.FieldName)
	}
	if m.from != nil {
		fields = append(fields, label.FieldFrom)
	}
	if m.mode != nil {
		fields = append(fields, label.FieldMode)
	}
	if m.conditions != nil {
		fields = append(fields, label.FieldConditions)
	}
	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 *LabelMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case label.FieldCreatedAt:
		return m.CreatedAt()
	case label.FieldUpdatedAt:
		return m.UpdatedAt()
	case label.FieldStatus:
		return m.Status()
	case label.FieldDeletedAt:
		return m.DeletedAt()
	case label.FieldType:
		return m.GetType()
	case label.FieldName:
		return m.Name()
	case label.FieldFrom:
		return m.From()
	case label.FieldMode:
		return m.Mode()
	case label.FieldConditions:
		return m.Conditions()
	}
	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 *LabelMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case label.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case label.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case label.FieldStatus:
		return m.OldStatus(ctx)
	case label.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case label.FieldType:
		return m.OldType(ctx)
	case label.FieldName:
		return m.OldName(ctx)
	case label.FieldFrom:
		return m.OldFrom(ctx)
	case label.FieldMode:
		return m.OldMode(ctx)
	case label.FieldConditions:
		return m.OldConditions(ctx)
	}
	return nil, fmt.Errorf("unknown Label 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 *LabelMutation) SetField(name string, value ent.Value) error {
	switch name {
	case label.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 label.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case label.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case label.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case label.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case label.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case label.FieldFrom:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFrom(v)
		return nil
	case label.FieldMode:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMode(v)
		return nil
	case label.FieldConditions:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditions(v)
		return nil
	}
	return fmt.Errorf("unknown Label field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *LabelMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(label.FieldStatus) {
		fields = append(fields, label.FieldStatus)
	}
	if m.FieldCleared(label.FieldDeletedAt) {
		fields = append(fields, label.FieldDeletedAt)
	}
	if m.FieldCleared(label.FieldConditions) {
		fields = append(fields, label.FieldConditions)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *LabelMutation) 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 *LabelMutation) ClearField(name string) error {
	switch name {
	case label.FieldStatus:
		m.ClearStatus()
		return nil
	case label.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case label.FieldConditions:
		m.ClearConditions()
		return nil
	}
	return fmt.Errorf("unknown Label 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 *LabelMutation) ResetField(name string) error {
	switch name {
	case label.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case label.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case label.FieldStatus:
		m.ResetStatus()
		return nil
	case label.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case label.FieldType:
		m.ResetType()
		return nil
	case label.FieldName:
		m.ResetName()
		return nil
	case label.FieldFrom:
		m.ResetFrom()
		return nil
	case label.FieldMode:
		m.ResetMode()
		return nil
	case label.FieldConditions:
		m.ResetConditions()
		return nil
	}
	return fmt.Errorf("unknown Label field %s", name)
}

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

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

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

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

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

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

// LabelRelationshipMutation represents an operation that mutates the LabelRelationship nodes in the graph.
type LabelRelationshipMutation struct {
	config
	op              Op
	typ             string
	id              *uint64
	created_at      *time.Time
	updated_at      *time.Time
	status          *uint8
	addstatus       *int8
	deleted_at      *time.Time
	clearedFields   map[string]struct{}
	contacts        *uint64
	clearedcontacts bool
	labels          *uint64
	clearedlabels   bool
	done            bool
	oldValue        func(context.Context) (*LabelRelationship, error)
	predicates      []predicate.LabelRelationship
}

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

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

// newLabelRelationshipMutation creates new mutation for the LabelRelationship entity.
func newLabelRelationshipMutation(c config, op Op, opts ...labelrelationshipOption) *LabelRelationshipMutation {
	m := &LabelRelationshipMutation{
		config:        c,
		op:            op,
		typ:           TypeLabelRelationship,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withLabelRelationship sets the old LabelRelationship of the mutation.
func withLabelRelationship(node *LabelRelationship) labelrelationshipOption {
	return func(m *LabelRelationshipMutation) {
		m.oldValue = func(context.Context) (*LabelRelationship, 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 LabelRelationshipMutation) 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 LabelRelationshipMutation) 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 LabelRelationship entities.
func (m *LabelRelationshipMutation) SetID(id uint64) {
	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 *LabelRelationshipMutation) ID() (id uint64, 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 *LabelRelationshipMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().LabelRelationship.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *LabelRelationshipMutation) 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 LabelRelationship entity.
// If the LabelRelationship 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 *LabelRelationshipMutation) 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 *LabelRelationshipMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *LabelRelationshipMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *LabelRelationshipMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[labelrelationship.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *LabelRelationshipMutation) StatusCleared() bool {
	_, ok := m.clearedFields[labelrelationship.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *LabelRelationshipMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, labelrelationship.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *LabelRelationshipMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *LabelRelationshipMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[labelrelationship.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *LabelRelationshipMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[labelrelationship.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *LabelRelationshipMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, labelrelationship.FieldDeletedAt)
}

// SetLabelID sets the "label_id" field.
func (m *LabelRelationshipMutation) SetLabelID(u uint64) {
	m.labels = &u
}

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

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

// ResetLabelID resets all changes to the "label_id" field.
func (m *LabelRelationshipMutation) ResetLabelID() {
	m.labels = nil
}

// SetContactID sets the "contact_id" field.
func (m *LabelRelationshipMutation) SetContactID(u uint64) {
	m.contacts = &u
}

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

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

// ResetContactID resets all changes to the "contact_id" field.
func (m *LabelRelationshipMutation) ResetContactID() {
	m.contacts = nil
}

// SetContactsID sets the "contacts" edge to the Contact entity by id.
func (m *LabelRelationshipMutation) SetContactsID(id uint64) {
	m.contacts = &id
}

// ClearContacts clears the "contacts" edge to the Contact entity.
func (m *LabelRelationshipMutation) ClearContacts() {
	m.clearedcontacts = true
	m.clearedFields[labelrelationship.FieldContactID] = struct{}{}
}

// ContactsCleared reports if the "contacts" edge to the Contact entity was cleared.
func (m *LabelRelationshipMutation) ContactsCleared() bool {
	return m.clearedcontacts
}

// ContactsID returns the "contacts" edge ID in the mutation.
func (m *LabelRelationshipMutation) ContactsID() (id uint64, exists bool) {
	if m.contacts != nil {
		return *m.contacts, true
	}
	return
}

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

// ResetContacts resets all changes to the "contacts" edge.
func (m *LabelRelationshipMutation) ResetContacts() {
	m.contacts = nil
	m.clearedcontacts = false
}

// SetLabelsID sets the "labels" edge to the Label entity by id.
func (m *LabelRelationshipMutation) SetLabelsID(id uint64) {
	m.labels = &id
}

// ClearLabels clears the "labels" edge to the Label entity.
func (m *LabelRelationshipMutation) ClearLabels() {
	m.clearedlabels = true
	m.clearedFields[labelrelationship.FieldLabelID] = struct{}{}
}

// LabelsCleared reports if the "labels" edge to the Label entity was cleared.
func (m *LabelRelationshipMutation) LabelsCleared() bool {
	return m.clearedlabels
}

// LabelsID returns the "labels" edge ID in the mutation.
func (m *LabelRelationshipMutation) LabelsID() (id uint64, exists bool) {
	if m.labels != nil {
		return *m.labels, true
	}
	return
}

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

// ResetLabels resets all changes to the "labels" edge.
func (m *LabelRelationshipMutation) ResetLabels() {
	m.labels = nil
	m.clearedlabels = false
}

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

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

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

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

// Type returns the node type of this mutation (LabelRelationship).
func (m *LabelRelationshipMutation) 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 *LabelRelationshipMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.created_at != nil {
		fields = append(fields, labelrelationship.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, labelrelationship.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, labelrelationship.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, labelrelationship.FieldDeletedAt)
	}
	if m.labels != nil {
		fields = append(fields, labelrelationship.FieldLabelID)
	}
	if m.contacts != nil {
		fields = append(fields, labelrelationship.FieldContactID)
	}
	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 *LabelRelationshipMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case labelrelationship.FieldCreatedAt:
		return m.CreatedAt()
	case labelrelationship.FieldUpdatedAt:
		return m.UpdatedAt()
	case labelrelationship.FieldStatus:
		return m.Status()
	case labelrelationship.FieldDeletedAt:
		return m.DeletedAt()
	case labelrelationship.FieldLabelID:
		return m.LabelID()
	case labelrelationship.FieldContactID:
		return m.ContactID()
	}
	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 *LabelRelationshipMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case labelrelationship.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case labelrelationship.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case labelrelationship.FieldStatus:
		return m.OldStatus(ctx)
	case labelrelationship.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case labelrelationship.FieldLabelID:
		return m.OldLabelID(ctx)
	case labelrelationship.FieldContactID:
		return m.OldContactID(ctx)
	}
	return nil, fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) SetField(name string, value ent.Value) error {
	switch name {
	case labelrelationship.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 labelrelationship.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case labelrelationship.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case labelrelationship.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case labelrelationship.FieldLabelID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLabelID(v)
		return nil
	case labelrelationship.FieldContactID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContactID(v)
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *LabelRelationshipMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, labelrelationship.FieldStatus)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *LabelRelationshipMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case labelrelationship.FieldStatus:
		return m.AddedStatus()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *LabelRelationshipMutation) AddField(name string, value ent.Value) error {
	switch name {
	case labelrelationship.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *LabelRelationshipMutation) 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 *LabelRelationshipMutation) ClearField(name string) error {
	switch name {
	case labelrelationship.FieldStatus:
		m.ClearStatus()
		return nil
	case labelrelationship.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) ResetField(name string) error {
	switch name {
	case labelrelationship.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case labelrelationship.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case labelrelationship.FieldStatus:
		m.ResetStatus()
		return nil
	case labelrelationship.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case labelrelationship.FieldLabelID:
		m.ResetLabelID()
		return nil
	case labelrelationship.FieldContactID:
		m.ResetContactID()
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *LabelRelationshipMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.contacts != nil {
		edges = append(edges, labelrelationship.EdgeContacts)
	}
	if m.labels != nil {
		edges = append(edges, labelrelationship.EdgeLabels)
	}
	return edges
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *LabelRelationshipMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedcontacts {
		edges = append(edges, labelrelationship.EdgeContacts)
	}
	if m.clearedlabels {
		edges = append(edges, labelrelationship.EdgeLabels)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *LabelRelationshipMutation) EdgeCleared(name string) bool {
	switch name {
	case labelrelationship.EdgeContacts:
		return m.clearedcontacts
	case labelrelationship.EdgeLabels:
		return m.clearedlabels
	}
	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 *LabelRelationshipMutation) ClearEdge(name string) error {
	switch name {
	case labelrelationship.EdgeContacts:
		m.ClearContacts()
		return nil
	case labelrelationship.EdgeLabels:
		m.ClearLabels()
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) ResetEdge(name string) error {
	switch name {
	case labelrelationship.EdgeContacts:
		m.ResetContacts()
		return nil
	case labelrelationship.EdgeLabels:
		m.ResetLabels()
		return nil
	}
	return fmt.Errorf("unknown LabelRelationship edge %s", name)
}

// MessageMutation represents an operation that mutates the Message nodes in the graph.
type MessageMutation struct {
	config
	op            Op
	typ           string
	id            *int
	wx_wxid       *string
	wxid          *string
	content       *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Message, error)
	predicates    []predicate.Message
}

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

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

// newMessageMutation creates new mutation for the Message entity.
func newMessageMutation(c config, op Op, opts ...messageOption) *MessageMutation {
	m := &MessageMutation{
		config:        c,
		op:            op,
		typ:           TypeMessage,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

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

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

// SetWxWxid sets the "wx_wxid" field.
func (m *MessageMutation) SetWxWxid(s string) {
	m.wx_wxid = &s
}

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

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

// ClearWxWxid clears the value of the "wx_wxid" field.
func (m *MessageMutation) ClearWxWxid() {
	m.wx_wxid = nil
	m.clearedFields[message.FieldWxWxid] = struct{}{}
}

// WxWxidCleared returns if the "wx_wxid" field was cleared in this mutation.
func (m *MessageMutation) WxWxidCleared() bool {
	_, ok := m.clearedFields[message.FieldWxWxid]
	return ok
}

// ResetWxWxid resets all changes to the "wx_wxid" field.
func (m *MessageMutation) ResetWxWxid() {
	m.wx_wxid = nil
	delete(m.clearedFields, message.FieldWxWxid)
}

// SetWxid sets the "wxid" field.
func (m *MessageMutation) SetWxid(s string) {
	m.wxid = &s
}

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

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

// ResetWxid resets all changes to the "wxid" field.
func (m *MessageMutation) ResetWxid() {
	m.wxid = nil
}

// SetContent sets the "content" field.
func (m *MessageMutation) SetContent(s string) {
	m.content = &s
}

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

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

// ResetContent resets all changes to the "content" field.
func (m *MessageMutation) ResetContent() {
	m.content = nil
}

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

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

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

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

// Type returns the node type of this mutation (Message).
func (m *MessageMutation) 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 *MessageMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.wx_wxid != nil {
		fields = append(fields, message.FieldWxWxid)
	}
	if m.wxid != nil {
		fields = append(fields, message.FieldWxid)
	}
	if m.content != nil {
		fields = append(fields, message.FieldContent)
	}
	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 *MessageMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case message.FieldWxWxid:
		return m.WxWxid()
	case message.FieldWxid:
		return m.Wxid()
	case message.FieldContent:
		return m.Content()
	}
	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 *MessageMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case message.FieldWxWxid:
		return m.OldWxWxid(ctx)
	case message.FieldWxid:
		return m.OldWxid(ctx)
	case message.FieldContent:
		return m.OldContent(ctx)
	}
	return nil, fmt.Errorf("unknown Message 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 *MessageMutation) SetField(name string, value ent.Value) error {
	switch name {
	case message.FieldWxWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxWxid(v)
		return nil
	case message.FieldWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxid(v)
		return nil
	case message.FieldContent:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContent(v)
		return nil
	}
	return fmt.Errorf("unknown Message field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MessageMutation) 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 *MessageMutation) ClearField(name string) error {
	switch name {
	case message.FieldWxWxid:
		m.ClearWxWxid()
		return nil
	}
	return fmt.Errorf("unknown Message 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 *MessageMutation) ResetField(name string) error {
	switch name {
	case message.FieldWxWxid:
		m.ResetWxWxid()
		return nil
	case message.FieldWxid:
		m.ResetWxid()
		return nil
	case message.FieldContent:
		m.ResetContent()
		return nil
	}
	return fmt.Errorf("unknown Message field %s", name)
}

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

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

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

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

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

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

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

// MessageRecordsMutation represents an operation that mutates the MessageRecords nodes in the graph.
type MessageRecordsMutation struct {
	config
	op                     Op
	typ                    string
	id                     *uint64
	created_at             *time.Time
	updated_at             *time.Time
	status                 *uint8
	addstatus              *int8
	deleted_at             *time.Time
	bot_wxid               *string
	contact_type           *int
	addcontact_type        *int
	contact_wxid           *string
	content_type           *int
	addcontent_type        *int
	content                *string
	meta                   *custom_types.Meta
	error_detail           *string
	send_time              *time.Time
	source_type            *int
	addsource_type         *int
	clearedFields          map[string]struct{}
	sop_stage              *uint64
	clearedsop_stage       bool
	sop_node               *uint64
	clearedsop_node        bool
	message_contact        *uint64
	clearedmessage_contact bool
	done                   bool
	oldValue               func(context.Context) (*MessageRecords, error)
	predicates             []predicate.MessageRecords
}

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

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

// newMessageRecordsMutation creates new mutation for the MessageRecords entity.
func newMessageRecordsMutation(c config, op Op, opts ...messagerecordsOption) *MessageRecordsMutation {
	m := &MessageRecordsMutation{
		config:        c,
		op:            op,
		typ:           TypeMessageRecords,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withMessageRecords sets the old MessageRecords of the mutation.
func withMessageRecords(node *MessageRecords) messagerecordsOption {
	return func(m *MessageRecordsMutation) {
		m.oldValue = func(context.Context) (*MessageRecords, 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 MessageRecordsMutation) 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 MessageRecordsMutation) 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 MessageRecords entities.
func (m *MessageRecordsMutation) SetID(id uint64) {
	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 *MessageRecordsMutation) ID() (id uint64, 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 *MessageRecordsMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().MessageRecords.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *MessageRecordsMutation) 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 MessageRecords entity.
// If the MessageRecords 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 *MessageRecordsMutation) 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 *MessageRecordsMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *MessageRecordsMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *MessageRecordsMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[messagerecords.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *MessageRecordsMutation) StatusCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *MessageRecordsMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, messagerecords.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *MessageRecordsMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *MessageRecordsMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[messagerecords.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *MessageRecordsMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *MessageRecordsMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, messagerecords.FieldDeletedAt)
}

// SetBotWxid sets the "bot_wxid" field.
func (m *MessageRecordsMutation) SetBotWxid(s string) {
	m.bot_wxid = &s
}

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

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

// ResetBotWxid resets all changes to the "bot_wxid" field.
func (m *MessageRecordsMutation) ResetBotWxid() {
	m.bot_wxid = nil
}

// SetContactID sets the "contact_id" field.
func (m *MessageRecordsMutation) SetContactID(u uint64) {
	m.message_contact = &u
}

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

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

// ClearContactID clears the value of the "contact_id" field.
func (m *MessageRecordsMutation) ClearContactID() {
	m.message_contact = nil
	m.clearedFields[messagerecords.FieldContactID] = struct{}{}
}

// ContactIDCleared returns if the "contact_id" field was cleared in this mutation.
func (m *MessageRecordsMutation) ContactIDCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldContactID]
	return ok
}

// ResetContactID resets all changes to the "contact_id" field.
func (m *MessageRecordsMutation) ResetContactID() {
	m.message_contact = nil
	delete(m.clearedFields, messagerecords.FieldContactID)
}

// SetContactType sets the "contact_type" field.
func (m *MessageRecordsMutation) SetContactType(i int) {
	m.contact_type = &i
	m.addcontact_type = nil
}

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

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

// AddContactType adds i to the "contact_type" field.
func (m *MessageRecordsMutation) AddContactType(i int) {
	if m.addcontact_type != nil {
		*m.addcontact_type += i
	} else {
		m.addcontact_type = &i
	}
}

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

// ResetContactType resets all changes to the "contact_type" field.
func (m *MessageRecordsMutation) ResetContactType() {
	m.contact_type = nil
	m.addcontact_type = nil
}

// SetContactWxid sets the "contact_wxid" field.
func (m *MessageRecordsMutation) SetContactWxid(s string) {
	m.contact_wxid = &s
}

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

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

// ResetContactWxid resets all changes to the "contact_wxid" field.
func (m *MessageRecordsMutation) ResetContactWxid() {
	m.contact_wxid = nil
}

// SetContentType sets the "content_type" field.
func (m *MessageRecordsMutation) SetContentType(i int) {
	m.content_type = &i
	m.addcontent_type = nil
}

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

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

// AddContentType adds i to the "content_type" field.
func (m *MessageRecordsMutation) AddContentType(i int) {
	if m.addcontent_type != nil {
		*m.addcontent_type += i
	} else {
		m.addcontent_type = &i
	}
}

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

// ResetContentType resets all changes to the "content_type" field.
func (m *MessageRecordsMutation) ResetContentType() {
	m.content_type = nil
	m.addcontent_type = nil
}

// SetContent sets the "content" field.
func (m *MessageRecordsMutation) SetContent(s string) {
	m.content = &s
}

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

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

// ResetContent resets all changes to the "content" field.
func (m *MessageRecordsMutation) ResetContent() {
	m.content = nil
}

// SetMeta sets the "meta" field.
func (m *MessageRecordsMutation) SetMeta(ct custom_types.Meta) {
	m.meta = &ct
}

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

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

// ClearMeta clears the value of the "meta" field.
func (m *MessageRecordsMutation) ClearMeta() {
	m.meta = nil
	m.clearedFields[messagerecords.FieldMeta] = struct{}{}
}

// MetaCleared returns if the "meta" field was cleared in this mutation.
func (m *MessageRecordsMutation) MetaCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldMeta]
	return ok
}

// ResetMeta resets all changes to the "meta" field.
func (m *MessageRecordsMutation) ResetMeta() {
	m.meta = nil
	delete(m.clearedFields, messagerecords.FieldMeta)
}

// SetErrorDetail sets the "error_detail" field.
func (m *MessageRecordsMutation) SetErrorDetail(s string) {
	m.error_detail = &s
}

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

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

// ResetErrorDetail resets all changes to the "error_detail" field.
func (m *MessageRecordsMutation) ResetErrorDetail() {
	m.error_detail = nil
}

// SetSendTime sets the "send_time" field.
func (m *MessageRecordsMutation) SetSendTime(t time.Time) {
	m.send_time = &t
}

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

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

// ClearSendTime clears the value of the "send_time" field.
func (m *MessageRecordsMutation) ClearSendTime() {
	m.send_time = nil
	m.clearedFields[messagerecords.FieldSendTime] = struct{}{}
}

// SendTimeCleared returns if the "send_time" field was cleared in this mutation.
func (m *MessageRecordsMutation) SendTimeCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldSendTime]
	return ok
}

// ResetSendTime resets all changes to the "send_time" field.
func (m *MessageRecordsMutation) ResetSendTime() {
	m.send_time = nil
	delete(m.clearedFields, messagerecords.FieldSendTime)
}

// SetSourceType sets the "source_type" field.
func (m *MessageRecordsMutation) SetSourceType(i int) {
	m.source_type = &i
	m.addsource_type = nil
}

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

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

// AddSourceType adds i to the "source_type" field.
func (m *MessageRecordsMutation) AddSourceType(i int) {
	if m.addsource_type != nil {
		*m.addsource_type += i
	} else {
		m.addsource_type = &i
	}
}

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

// ResetSourceType resets all changes to the "source_type" field.
func (m *MessageRecordsMutation) ResetSourceType() {
	m.source_type = nil
	m.addsource_type = nil
}

// SetSourceID sets the "source_id" field.
func (m *MessageRecordsMutation) SetSourceID(u uint64) {
	m.sop_stage = &u
}

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

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

// ClearSourceID clears the value of the "source_id" field.
func (m *MessageRecordsMutation) ClearSourceID() {
	m.sop_stage = nil
	m.clearedFields[messagerecords.FieldSourceID] = struct{}{}
}

// SourceIDCleared returns if the "source_id" field was cleared in this mutation.
func (m *MessageRecordsMutation) SourceIDCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldSourceID]
	return ok
}

// ResetSourceID resets all changes to the "source_id" field.
func (m *MessageRecordsMutation) ResetSourceID() {
	m.sop_stage = nil
	delete(m.clearedFields, messagerecords.FieldSourceID)
}

// SetSubSourceID sets the "sub_source_id" field.
func (m *MessageRecordsMutation) SetSubSourceID(u uint64) {
	m.sop_node = &u
}

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

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

// ClearSubSourceID clears the value of the "sub_source_id" field.
func (m *MessageRecordsMutation) ClearSubSourceID() {
	m.sop_node = nil
	m.clearedFields[messagerecords.FieldSubSourceID] = struct{}{}
}

// SubSourceIDCleared returns if the "sub_source_id" field was cleared in this mutation.
func (m *MessageRecordsMutation) SubSourceIDCleared() bool {
	_, ok := m.clearedFields[messagerecords.FieldSubSourceID]
	return ok
}

// ResetSubSourceID resets all changes to the "sub_source_id" field.
func (m *MessageRecordsMutation) ResetSubSourceID() {
	m.sop_node = nil
	delete(m.clearedFields, messagerecords.FieldSubSourceID)
}

// SetSopStageID sets the "sop_stage" edge to the SopStage entity by id.
func (m *MessageRecordsMutation) SetSopStageID(id uint64) {
	m.sop_stage = &id
}

// ClearSopStage clears the "sop_stage" edge to the SopStage entity.
func (m *MessageRecordsMutation) ClearSopStage() {
	m.clearedsop_stage = true
	m.clearedFields[messagerecords.FieldSourceID] = struct{}{}
}

// SopStageCleared reports if the "sop_stage" edge to the SopStage entity was cleared.
func (m *MessageRecordsMutation) SopStageCleared() bool {
	return m.SourceIDCleared() || m.clearedsop_stage
}

// SopStageID returns the "sop_stage" edge ID in the mutation.
func (m *MessageRecordsMutation) SopStageID() (id uint64, exists bool) {
	if m.sop_stage != nil {
		return *m.sop_stage, true
	}
	return
}

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

// ResetSopStage resets all changes to the "sop_stage" edge.
func (m *MessageRecordsMutation) ResetSopStage() {
	m.sop_stage = nil
	m.clearedsop_stage = false
}

// SetSopNodeID sets the "sop_node" edge to the SopNode entity by id.
func (m *MessageRecordsMutation) SetSopNodeID(id uint64) {
	m.sop_node = &id
}

// ClearSopNode clears the "sop_node" edge to the SopNode entity.
func (m *MessageRecordsMutation) ClearSopNode() {
	m.clearedsop_node = true
	m.clearedFields[messagerecords.FieldSubSourceID] = struct{}{}
}

// SopNodeCleared reports if the "sop_node" edge to the SopNode entity was cleared.
func (m *MessageRecordsMutation) SopNodeCleared() bool {
	return m.SubSourceIDCleared() || m.clearedsop_node
}

// SopNodeID returns the "sop_node" edge ID in the mutation.
func (m *MessageRecordsMutation) SopNodeID() (id uint64, exists bool) {
	if m.sop_node != nil {
		return *m.sop_node, true
	}
	return
}

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

// ResetSopNode resets all changes to the "sop_node" edge.
func (m *MessageRecordsMutation) ResetSopNode() {
	m.sop_node = nil
	m.clearedsop_node = false
}

// SetMessageContactID sets the "message_contact" edge to the Contact entity by id.
func (m *MessageRecordsMutation) SetMessageContactID(id uint64) {
	m.message_contact = &id
}

// ClearMessageContact clears the "message_contact" edge to the Contact entity.
func (m *MessageRecordsMutation) ClearMessageContact() {
	m.clearedmessage_contact = true
	m.clearedFields[messagerecords.FieldContactID] = struct{}{}
}

// MessageContactCleared reports if the "message_contact" edge to the Contact entity was cleared.
func (m *MessageRecordsMutation) MessageContactCleared() bool {
	return m.ContactIDCleared() || m.clearedmessage_contact
}

// MessageContactID returns the "message_contact" edge ID in the mutation.
func (m *MessageRecordsMutation) MessageContactID() (id uint64, exists bool) {
	if m.message_contact != nil {
		return *m.message_contact, true
	}
	return
}

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

// ResetMessageContact resets all changes to the "message_contact" edge.
func (m *MessageRecordsMutation) ResetMessageContact() {
	m.message_contact = nil
	m.clearedmessage_contact = false
}

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

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

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

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

// Type returns the node type of this mutation (MessageRecords).
func (m *MessageRecordsMutation) 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 *MessageRecordsMutation) Fields() []string {
	fields := make([]string, 0, 16)
	if m.created_at != nil {
		fields = append(fields, messagerecords.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, messagerecords.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, messagerecords.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, messagerecords.FieldDeletedAt)
	}
	if m.bot_wxid != nil {
		fields = append(fields, messagerecords.FieldBotWxid)
	}
	if m.message_contact != nil {
		fields = append(fields, messagerecords.FieldContactID)
	}
	if m.contact_type != nil {
		fields = append(fields, messagerecords.FieldContactType)
	}
	if m.contact_wxid != nil {
		fields = append(fields, messagerecords.FieldContactWxid)
	}
	if m.content_type != nil {
		fields = append(fields, messagerecords.FieldContentType)
	}
	if m.content != nil {
		fields = append(fields, messagerecords.FieldContent)
	}
	if m.meta != nil {
		fields = append(fields, messagerecords.FieldMeta)
	}
	if m.error_detail != nil {
		fields = append(fields, messagerecords.FieldErrorDetail)
	}
	if m.send_time != nil {
		fields = append(fields, messagerecords.FieldSendTime)
	}
	if m.source_type != nil {
		fields = append(fields, messagerecords.FieldSourceType)
	}
	if m.sop_stage != nil {
		fields = append(fields, messagerecords.FieldSourceID)
	}
	if m.sop_node != nil {
		fields = append(fields, messagerecords.FieldSubSourceID)
	}
	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 *MessageRecordsMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case messagerecords.FieldCreatedAt:
		return m.CreatedAt()
	case messagerecords.FieldUpdatedAt:
		return m.UpdatedAt()
	case messagerecords.FieldStatus:
		return m.Status()
	case messagerecords.FieldDeletedAt:
		return m.DeletedAt()
	case messagerecords.FieldBotWxid:
		return m.BotWxid()
	case messagerecords.FieldContactID:
		return m.ContactID()
	case messagerecords.FieldContactType:
		return m.ContactType()
	case messagerecords.FieldContactWxid:
		return m.ContactWxid()
	case messagerecords.FieldContentType:
		return m.ContentType()
	case messagerecords.FieldContent:
		return m.Content()
	case messagerecords.FieldMeta:
		return m.Meta()
	case messagerecords.FieldErrorDetail:
		return m.ErrorDetail()
	case messagerecords.FieldSendTime:
		return m.SendTime()
	case messagerecords.FieldSourceType:
		return m.SourceType()
	case messagerecords.FieldSourceID:
		return m.SourceID()
	case messagerecords.FieldSubSourceID:
		return m.SubSourceID()
	}
	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 *MessageRecordsMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case messagerecords.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case messagerecords.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case messagerecords.FieldStatus:
		return m.OldStatus(ctx)
	case messagerecords.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case messagerecords.FieldBotWxid:
		return m.OldBotWxid(ctx)
	case messagerecords.FieldContactID:
		return m.OldContactID(ctx)
	case messagerecords.FieldContactType:
		return m.OldContactType(ctx)
	case messagerecords.FieldContactWxid:
		return m.OldContactWxid(ctx)
	case messagerecords.FieldContentType:
		return m.OldContentType(ctx)
	case messagerecords.FieldContent:
		return m.OldContent(ctx)
	case messagerecords.FieldMeta:
		return m.OldMeta(ctx)
	case messagerecords.FieldErrorDetail:
		return m.OldErrorDetail(ctx)
	case messagerecords.FieldSendTime:
		return m.OldSendTime(ctx)
	case messagerecords.FieldSourceType:
		return m.OldSourceType(ctx)
	case messagerecords.FieldSourceID:
		return m.OldSourceID(ctx)
	case messagerecords.FieldSubSourceID:
		return m.OldSubSourceID(ctx)
	}
	return nil, fmt.Errorf("unknown MessageRecords 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 *MessageRecordsMutation) SetField(name string, value ent.Value) error {
	switch name {
	case messagerecords.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 messagerecords.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case messagerecords.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case messagerecords.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case messagerecords.FieldBotWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotWxid(v)
		return nil
	case messagerecords.FieldContactID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContactID(v)
		return nil
	case messagerecords.FieldContactType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContactType(v)
		return nil
	case messagerecords.FieldContactWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContactWxid(v)
		return nil
	case messagerecords.FieldContentType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContentType(v)
		return nil
	case messagerecords.FieldContent:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContent(v)
		return nil
	case messagerecords.FieldMeta:
		v, ok := value.(custom_types.Meta)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMeta(v)
		return nil
	case messagerecords.FieldErrorDetail:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetErrorDetail(v)
		return nil
	case messagerecords.FieldSendTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSendTime(v)
		return nil
	case messagerecords.FieldSourceType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSourceType(v)
		return nil
	case messagerecords.FieldSourceID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSourceID(v)
		return nil
	case messagerecords.FieldSubSourceID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSubSourceID(v)
		return nil
	}
	return fmt.Errorf("unknown MessageRecords field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *MessageRecordsMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, messagerecords.FieldStatus)
	}
	if m.addcontact_type != nil {
		fields = append(fields, messagerecords.FieldContactType)
	}
	if m.addcontent_type != nil {
		fields = append(fields, messagerecords.FieldContentType)
	}
	if m.addsource_type != nil {
		fields = append(fields, messagerecords.FieldSourceType)
	}
	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 *MessageRecordsMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case messagerecords.FieldStatus:
		return m.AddedStatus()
	case messagerecords.FieldContactType:
		return m.AddedContactType()
	case messagerecords.FieldContentType:
		return m.AddedContentType()
	case messagerecords.FieldSourceType:
		return m.AddedSourceType()
	}
	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 *MessageRecordsMutation) AddField(name string, value ent.Value) error {
	switch name {
	case messagerecords.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case messagerecords.FieldContactType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddContactType(v)
		return nil
	case messagerecords.FieldContentType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddContentType(v)
		return nil
	case messagerecords.FieldSourceType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSourceType(v)
		return nil
	}
	return fmt.Errorf("unknown MessageRecords numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *MessageRecordsMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(messagerecords.FieldStatus) {
		fields = append(fields, messagerecords.FieldStatus)
	}
	if m.FieldCleared(messagerecords.FieldDeletedAt) {
		fields = append(fields, messagerecords.FieldDeletedAt)
	}
	if m.FieldCleared(messagerecords.FieldContactID) {
		fields = append(fields, messagerecords.FieldContactID)
	}
	if m.FieldCleared(messagerecords.FieldMeta) {
		fields = append(fields, messagerecords.FieldMeta)
	}
	if m.FieldCleared(messagerecords.FieldSendTime) {
		fields = append(fields, messagerecords.FieldSendTime)
	}
	if m.FieldCleared(messagerecords.FieldSourceID) {
		fields = append(fields, messagerecords.FieldSourceID)
	}
	if m.FieldCleared(messagerecords.FieldSubSourceID) {
		fields = append(fields, messagerecords.FieldSubSourceID)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MessageRecordsMutation) 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 *MessageRecordsMutation) ClearField(name string) error {
	switch name {
	case messagerecords.FieldStatus:
		m.ClearStatus()
		return nil
	case messagerecords.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case messagerecords.FieldContactID:
		m.ClearContactID()
		return nil
	case messagerecords.FieldMeta:
		m.ClearMeta()
		return nil
	case messagerecords.FieldSendTime:
		m.ClearSendTime()
		return nil
	case messagerecords.FieldSourceID:
		m.ClearSourceID()
		return nil
	case messagerecords.FieldSubSourceID:
		m.ClearSubSourceID()
		return nil
	}
	return fmt.Errorf("unknown MessageRecords 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 *MessageRecordsMutation) ResetField(name string) error {
	switch name {
	case messagerecords.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case messagerecords.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case messagerecords.FieldStatus:
		m.ResetStatus()
		return nil
	case messagerecords.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case messagerecords.FieldBotWxid:
		m.ResetBotWxid()
		return nil
	case messagerecords.FieldContactID:
		m.ResetContactID()
		return nil
	case messagerecords.FieldContactType:
		m.ResetContactType()
		return nil
	case messagerecords.FieldContactWxid:
		m.ResetContactWxid()
		return nil
	case messagerecords.FieldContentType:
		m.ResetContentType()
		return nil
	case messagerecords.FieldContent:
		m.ResetContent()
		return nil
	case messagerecords.FieldMeta:
		m.ResetMeta()
		return nil
	case messagerecords.FieldErrorDetail:
		m.ResetErrorDetail()
		return nil
	case messagerecords.FieldSendTime:
		m.ResetSendTime()
		return nil
	case messagerecords.FieldSourceType:
		m.ResetSourceType()
		return nil
	case messagerecords.FieldSourceID:
		m.ResetSourceID()
		return nil
	case messagerecords.FieldSubSourceID:
		m.ResetSubSourceID()
		return nil
	}
	return fmt.Errorf("unknown MessageRecords field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *MessageRecordsMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.sop_stage != nil {
		edges = append(edges, messagerecords.EdgeSopStage)
	}
	if m.sop_node != nil {
		edges = append(edges, messagerecords.EdgeSopNode)
	}
	if m.message_contact != nil {
		edges = append(edges, messagerecords.EdgeMessageContact)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *MessageRecordsMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case messagerecords.EdgeSopStage:
		if id := m.sop_stage; id != nil {
			return []ent.Value{*id}
		}
	case messagerecords.EdgeSopNode:
		if id := m.sop_node; id != nil {
			return []ent.Value{*id}
		}
	case messagerecords.EdgeMessageContact:
		if id := m.message_contact; id != nil {
			return []ent.Value{*id}
		}
	}
	return nil
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *MessageRecordsMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedsop_stage {
		edges = append(edges, messagerecords.EdgeSopStage)
	}
	if m.clearedsop_node {
		edges = append(edges, messagerecords.EdgeSopNode)
	}
	if m.clearedmessage_contact {
		edges = append(edges, messagerecords.EdgeMessageContact)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *MessageRecordsMutation) EdgeCleared(name string) bool {
	switch name {
	case messagerecords.EdgeSopStage:
		return m.clearedsop_stage
	case messagerecords.EdgeSopNode:
		return m.clearedsop_node
	case messagerecords.EdgeMessageContact:
		return m.clearedmessage_contact
	}
	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 *MessageRecordsMutation) ClearEdge(name string) error {
	switch name {
	case messagerecords.EdgeSopStage:
		m.ClearSopStage()
		return nil
	case messagerecords.EdgeSopNode:
		m.ClearSopNode()
		return nil
	case messagerecords.EdgeMessageContact:
		m.ClearMessageContact()
		return nil
	}
	return fmt.Errorf("unknown MessageRecords 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 *MessageRecordsMutation) ResetEdge(name string) error {
	switch name {
	case messagerecords.EdgeSopStage:
		m.ResetSopStage()
		return nil
	case messagerecords.EdgeSopNode:
		m.ResetSopNode()
		return nil
	case messagerecords.EdgeMessageContact:
		m.ResetMessageContact()
		return nil
	}
	return fmt.Errorf("unknown MessageRecords edge %s", name)
}

// ServerMutation represents an operation that mutates the Server nodes in the graph.
type ServerMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	status        *uint8
	addstatus     *int8
	deleted_at    *time.Time
	name          *string
	public_ip     *string
	private_ip    *string
	admin_port    *string
	clearedFields map[string]struct{}
	wxs           map[uint64]struct{}
	removedwxs    map[uint64]struct{}
	clearedwxs    bool
	done          bool
	oldValue      func(context.Context) (*Server, error)
	predicates    []predicate.Server
}

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

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

// newServerMutation creates new mutation for the Server entity.
func newServerMutation(c config, op Op, opts ...serverOption) *ServerMutation {
	m := &ServerMutation{
		config:        c,
		op:            op,
		typ:           TypeServer,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withServer sets the old Server of the mutation.
func withServer(node *Server) serverOption {
	return func(m *ServerMutation) {
		m.oldValue = func(context.Context) (*Server, 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 ServerMutation) 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 ServerMutation) 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 Server entities.
func (m *ServerMutation) SetID(id uint64) {
	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 *ServerMutation) ID() (id uint64, 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 *ServerMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Server.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *ServerMutation) 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 Server entity.
// If the Server 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 *ServerMutation) 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 *ServerMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *ServerMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *ServerMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[server.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *ServerMutation) StatusCleared() bool {
	_, ok := m.clearedFields[server.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *ServerMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, server.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *ServerMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *ServerMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[server.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *ServerMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[server.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *ServerMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, server.FieldDeletedAt)
}

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

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

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

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

// SetPublicIP sets the "public_ip" field.
func (m *ServerMutation) SetPublicIP(s string) {
	m.public_ip = &s
}

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

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

// ResetPublicIP resets all changes to the "public_ip" field.
func (m *ServerMutation) ResetPublicIP() {
	m.public_ip = nil
}

// SetPrivateIP sets the "private_ip" field.
func (m *ServerMutation) SetPrivateIP(s string) {
	m.private_ip = &s
}

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

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

// ResetPrivateIP resets all changes to the "private_ip" field.
func (m *ServerMutation) ResetPrivateIP() {
	m.private_ip = nil
}

// SetAdminPort sets the "admin_port" field.
func (m *ServerMutation) SetAdminPort(s string) {
	m.admin_port = &s
}

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

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

// ResetAdminPort resets all changes to the "admin_port" field.
func (m *ServerMutation) ResetAdminPort() {
	m.admin_port = nil
}

// AddWxIDs adds the "wxs" edge to the Wx entity by ids.
func (m *ServerMutation) AddWxIDs(ids ...uint64) {
	if m.wxs == nil {
		m.wxs = make(map[uint64]struct{})
	}
	for i := range ids {
		m.wxs[ids[i]] = struct{}{}
	}
}

// ClearWxs clears the "wxs" edge to the Wx entity.
func (m *ServerMutation) ClearWxs() {
	m.clearedwxs = true
}

// WxsCleared reports if the "wxs" edge to the Wx entity was cleared.
func (m *ServerMutation) WxsCleared() bool {
	return m.clearedwxs
}

// RemoveWxIDs removes the "wxs" edge to the Wx entity by IDs.
func (m *ServerMutation) RemoveWxIDs(ids ...uint64) {
	if m.removedwxs == nil {
		m.removedwxs = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.wxs, ids[i])
		m.removedwxs[ids[i]] = struct{}{}
	}
}

// RemovedWxs returns the removed IDs of the "wxs" edge to the Wx entity.
func (m *ServerMutation) RemovedWxsIDs() (ids []uint64) {
	for id := range m.removedwxs {
		ids = append(ids, id)
	}
	return
}

// WxsIDs returns the "wxs" edge IDs in the mutation.
func (m *ServerMutation) WxsIDs() (ids []uint64) {
	for id := range m.wxs {
		ids = append(ids, id)
	}
	return
}

// ResetWxs resets all changes to the "wxs" edge.
func (m *ServerMutation) ResetWxs() {
	m.wxs = nil
	m.clearedwxs = false
	m.removedwxs = nil
}

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

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

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

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

// Type returns the node type of this mutation (Server).
func (m *ServerMutation) 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 *ServerMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, server.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, server.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, server.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, server.FieldDeletedAt)
	}
	if m.name != nil {
		fields = append(fields, server.FieldName)
	}
	if m.public_ip != nil {
		fields = append(fields, server.FieldPublicIP)
	}
	if m.private_ip != nil {
		fields = append(fields, server.FieldPrivateIP)
	}
	if m.admin_port != nil {
		fields = append(fields, server.FieldAdminPort)
	}
	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 *ServerMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case server.FieldCreatedAt:
		return m.CreatedAt()
	case server.FieldUpdatedAt:
		return m.UpdatedAt()
	case server.FieldStatus:
		return m.Status()
	case server.FieldDeletedAt:
		return m.DeletedAt()
	case server.FieldName:
		return m.Name()
	case server.FieldPublicIP:
		return m.PublicIP()
	case server.FieldPrivateIP:
		return m.PrivateIP()
	case server.FieldAdminPort:
		return m.AdminPort()
	}
	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 *ServerMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case server.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case server.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case server.FieldStatus:
		return m.OldStatus(ctx)
	case server.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case server.FieldName:
		return m.OldName(ctx)
	case server.FieldPublicIP:
		return m.OldPublicIP(ctx)
	case server.FieldPrivateIP:
		return m.OldPrivateIP(ctx)
	case server.FieldAdminPort:
		return m.OldAdminPort(ctx)
	}
	return nil, fmt.Errorf("unknown Server 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 *ServerMutation) SetField(name string, value ent.Value) error {
	switch name {
	case server.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 server.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case server.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case server.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case server.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case server.FieldPublicIP:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPublicIP(v)
		return nil
	case server.FieldPrivateIP:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPrivateIP(v)
		return nil
	case server.FieldAdminPort:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAdminPort(v)
		return nil
	}
	return fmt.Errorf("unknown Server field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ServerMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, server.FieldStatus)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *ServerMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case server.FieldStatus:
		return m.AddedStatus()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *ServerMutation) AddField(name string, value ent.Value) error {
	switch name {
	case server.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	}
	return fmt.Errorf("unknown Server numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ServerMutation) 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 *ServerMutation) ClearField(name string) error {
	switch name {
	case server.FieldStatus:
		m.ClearStatus()
		return nil
	case server.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Server 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 *ServerMutation) ResetField(name string) error {
	switch name {
	case server.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case server.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case server.FieldStatus:
		m.ResetStatus()
		return nil
	case server.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case server.FieldName:
		m.ResetName()
		return nil
	case server.FieldPublicIP:
		m.ResetPublicIP()
		return nil
	case server.FieldPrivateIP:
		m.ResetPrivateIP()
		return nil
	case server.FieldAdminPort:
		m.ResetAdminPort()
		return nil
	}
	return fmt.Errorf("unknown Server field %s", name)
}

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

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

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

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

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

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

// SopNodeMutation represents an operation that mutates the SopNode nodes in the graph.
type SopNodeMutation struct {
	config
	op                    Op
	typ                   string
	id                    *uint64
	created_at            *time.Time
	updated_at            *time.Time
	status                *uint8
	addstatus             *int8
	deleted_at            *time.Time
	parent_id             *uint64
	addparent_id          *int64
	name                  *string
	condition_type        *int
	addcondition_type     *int
	condition_list        *[]string
	appendcondition_list  []string
	no_reply_condition    *uint64
	addno_reply_condition *int64
	action_message        *[]custom_types.Action
	appendaction_message  []custom_types.Action
	action_label          *[]uint64
	appendaction_label    []uint64
	clearedFields         map[string]struct{}
	sop_stage             *uint64
	clearedsop_stage      bool
	node_messages         map[uint64]struct{}
	removednode_messages  map[uint64]struct{}
	clearednode_messages  bool
	done                  bool
	oldValue              func(context.Context) (*SopNode, error)
	predicates            []predicate.SopNode
}

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

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

// newSopNodeMutation creates new mutation for the SopNode entity.
func newSopNodeMutation(c config, op Op, opts ...sopnodeOption) *SopNodeMutation {
	m := &SopNodeMutation{
		config:        c,
		op:            op,
		typ:           TypeSopNode,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withSopNode sets the old SopNode of the mutation.
func withSopNode(node *SopNode) sopnodeOption {
	return func(m *SopNodeMutation) {
		m.oldValue = func(context.Context) (*SopNode, 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 SopNodeMutation) 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 SopNodeMutation) 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 SopNode entities.
func (m *SopNodeMutation) SetID(id uint64) {
	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 *SopNodeMutation) ID() (id uint64, 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 *SopNodeMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().SopNode.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *SopNodeMutation) 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 SopNode entity.
// If the SopNode 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 *SopNodeMutation) 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 *SopNodeMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *SopNodeMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *SopNodeMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[sopnode.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *SopNodeMutation) StatusCleared() bool {
	_, ok := m.clearedFields[sopnode.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *SopNodeMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, sopnode.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *SopNodeMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *SopNodeMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[sopnode.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *SopNodeMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[sopnode.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *SopNodeMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, sopnode.FieldDeletedAt)
}

// SetStageID sets the "stage_id" field.
func (m *SopNodeMutation) SetStageID(u uint64) {
	m.sop_stage = &u
}

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

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

// ResetStageID resets all changes to the "stage_id" field.
func (m *SopNodeMutation) ResetStageID() {
	m.sop_stage = nil
}

// SetParentID sets the "parent_id" field.
func (m *SopNodeMutation) SetParentID(u uint64) {
	m.parent_id = &u
	m.addparent_id = nil
}

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

// OldParentID returns the old "parent_id" field's value of the SopNode entity.
// If the SopNode 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 *SopNodeMutation) OldParentID(ctx context.Context) (v uint64, 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
}

// AddParentID adds u to the "parent_id" field.
func (m *SopNodeMutation) AddParentID(u int64) {
	if m.addparent_id != nil {
		*m.addparent_id += u
	} else {
		m.addparent_id = &u
	}
}

// AddedParentID returns the value that was added to the "parent_id" field in this mutation.
func (m *SopNodeMutation) AddedParentID() (r int64, exists bool) {
	v := m.addparent_id
	if v == nil {
		return
	}
	return *v, true
}

// ResetParentID resets all changes to the "parent_id" field.
func (m *SopNodeMutation) ResetParentID() {
	m.parent_id = nil
	m.addparent_id = nil
}

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

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

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

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

// SetConditionType sets the "condition_type" field.
func (m *SopNodeMutation) SetConditionType(i int) {
	m.condition_type = &i
	m.addcondition_type = nil
}

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

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

// AddConditionType adds i to the "condition_type" field.
func (m *SopNodeMutation) AddConditionType(i int) {
	if m.addcondition_type != nil {
		*m.addcondition_type += i
	} else {
		m.addcondition_type = &i
	}
}

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

// ResetConditionType resets all changes to the "condition_type" field.
func (m *SopNodeMutation) ResetConditionType() {
	m.condition_type = nil
	m.addcondition_type = nil
}

// SetConditionList sets the "condition_list" field.
func (m *SopNodeMutation) SetConditionList(s []string) {
	m.condition_list = &s
	m.appendcondition_list = nil
}

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

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

// AppendConditionList adds s to the "condition_list" field.
func (m *SopNodeMutation) AppendConditionList(s []string) {
	m.appendcondition_list = append(m.appendcondition_list, s...)
}

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

// ClearConditionList clears the value of the "condition_list" field.
func (m *SopNodeMutation) ClearConditionList() {
	m.condition_list = nil
	m.appendcondition_list = nil
	m.clearedFields[sopnode.FieldConditionList] = struct{}{}
}

// ConditionListCleared returns if the "condition_list" field was cleared in this mutation.
func (m *SopNodeMutation) ConditionListCleared() bool {
	_, ok := m.clearedFields[sopnode.FieldConditionList]
	return ok
}

// ResetConditionList resets all changes to the "condition_list" field.
func (m *SopNodeMutation) ResetConditionList() {
	m.condition_list = nil
	m.appendcondition_list = nil
	delete(m.clearedFields, sopnode.FieldConditionList)
}

// SetNoReplyCondition sets the "no_reply_condition" field.
func (m *SopNodeMutation) SetNoReplyCondition(u uint64) {
	m.no_reply_condition = &u
	m.addno_reply_condition = nil
}

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

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

// AddNoReplyCondition adds u to the "no_reply_condition" field.
func (m *SopNodeMutation) AddNoReplyCondition(u int64) {
	if m.addno_reply_condition != nil {
		*m.addno_reply_condition += u
	} else {
		m.addno_reply_condition = &u
	}
}

// AddedNoReplyCondition returns the value that was added to the "no_reply_condition" field in this mutation.
func (m *SopNodeMutation) AddedNoReplyCondition() (r int64, exists bool) {
	v := m.addno_reply_condition
	if v == nil {
		return
	}
	return *v, true
}

// ResetNoReplyCondition resets all changes to the "no_reply_condition" field.
func (m *SopNodeMutation) ResetNoReplyCondition() {
	m.no_reply_condition = nil
	m.addno_reply_condition = nil
}

// SetActionMessage sets the "action_message" field.
func (m *SopNodeMutation) SetActionMessage(ct []custom_types.Action) {
	m.action_message = &ct
	m.appendaction_message = nil
}

// ActionMessage returns the value of the "action_message" field in the mutation.
func (m *SopNodeMutation) ActionMessage() (r []custom_types.Action, exists bool) {
	v := m.action_message
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendActionMessage adds ct to the "action_message" field.
func (m *SopNodeMutation) AppendActionMessage(ct []custom_types.Action) {
	m.appendaction_message = append(m.appendaction_message, ct...)
}

// AppendedActionMessage returns the list of values that were appended to the "action_message" field in this mutation.
func (m *SopNodeMutation) AppendedActionMessage() ([]custom_types.Action, bool) {
	if len(m.appendaction_message) == 0 {
		return nil, false
	}
	return m.appendaction_message, true
}

// ClearActionMessage clears the value of the "action_message" field.
func (m *SopNodeMutation) ClearActionMessage() {
	m.action_message = nil
	m.appendaction_message = nil
	m.clearedFields[sopnode.FieldActionMessage] = struct{}{}
}

// ActionMessageCleared returns if the "action_message" field was cleared in this mutation.
func (m *SopNodeMutation) ActionMessageCleared() bool {
	_, ok := m.clearedFields[sopnode.FieldActionMessage]
	return ok
}

// ResetActionMessage resets all changes to the "action_message" field.
func (m *SopNodeMutation) ResetActionMessage() {
	m.action_message = nil
	m.appendaction_message = nil
	delete(m.clearedFields, sopnode.FieldActionMessage)
}

// SetActionLabel sets the "action_label" field.
func (m *SopNodeMutation) SetActionLabel(u []uint64) {
	m.action_label = &u
	m.appendaction_label = nil
}

// ActionLabel returns the value of the "action_label" field in the mutation.
func (m *SopNodeMutation) ActionLabel() (r []uint64, exists bool) {
	v := m.action_label
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendActionLabel adds u to the "action_label" field.
func (m *SopNodeMutation) AppendActionLabel(u []uint64) {
	m.appendaction_label = append(m.appendaction_label, u...)
}

// AppendedActionLabel returns the list of values that were appended to the "action_label" field in this mutation.
func (m *SopNodeMutation) AppendedActionLabel() ([]uint64, bool) {
	if len(m.appendaction_label) == 0 {
		return nil, false
	}
	return m.appendaction_label, true
}

// ClearActionLabel clears the value of the "action_label" field.
func (m *SopNodeMutation) ClearActionLabel() {
	m.action_label = nil
	m.appendaction_label = nil
	m.clearedFields[sopnode.FieldActionLabel] = struct{}{}
}

// ActionLabelCleared returns if the "action_label" field was cleared in this mutation.
func (m *SopNodeMutation) ActionLabelCleared() bool {
	_, ok := m.clearedFields[sopnode.FieldActionLabel]
	return ok
}

// ResetActionLabel resets all changes to the "action_label" field.
func (m *SopNodeMutation) ResetActionLabel() {
	m.action_label = nil
	m.appendaction_label = nil
	delete(m.clearedFields, sopnode.FieldActionLabel)
}

// SetSopStageID sets the "sop_stage" edge to the SopStage entity by id.
func (m *SopNodeMutation) SetSopStageID(id uint64) {
	m.sop_stage = &id
}

// ClearSopStage clears the "sop_stage" edge to the SopStage entity.
func (m *SopNodeMutation) ClearSopStage() {
	m.clearedsop_stage = true
	m.clearedFields[sopnode.FieldStageID] = struct{}{}
}

// SopStageCleared reports if the "sop_stage" edge to the SopStage entity was cleared.
func (m *SopNodeMutation) SopStageCleared() bool {
	return m.clearedsop_stage
}

// SopStageID returns the "sop_stage" edge ID in the mutation.
func (m *SopNodeMutation) SopStageID() (id uint64, exists bool) {
	if m.sop_stage != nil {
		return *m.sop_stage, true
	}
	return
}

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

// ResetSopStage resets all changes to the "sop_stage" edge.
func (m *SopNodeMutation) ResetSopStage() {
	m.sop_stage = nil
	m.clearedsop_stage = false
}

// AddNodeMessageIDs adds the "node_messages" edge to the MessageRecords entity by ids.
func (m *SopNodeMutation) AddNodeMessageIDs(ids ...uint64) {
	if m.node_messages == nil {
		m.node_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		m.node_messages[ids[i]] = struct{}{}
	}
}

// ClearNodeMessages clears the "node_messages" edge to the MessageRecords entity.
func (m *SopNodeMutation) ClearNodeMessages() {
	m.clearednode_messages = true
}

// NodeMessagesCleared reports if the "node_messages" edge to the MessageRecords entity was cleared.
func (m *SopNodeMutation) NodeMessagesCleared() bool {
	return m.clearednode_messages
}

// RemoveNodeMessageIDs removes the "node_messages" edge to the MessageRecords entity by IDs.
func (m *SopNodeMutation) RemoveNodeMessageIDs(ids ...uint64) {
	if m.removednode_messages == nil {
		m.removednode_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.node_messages, ids[i])
		m.removednode_messages[ids[i]] = struct{}{}
	}
}

// RemovedNodeMessages returns the removed IDs of the "node_messages" edge to the MessageRecords entity.
func (m *SopNodeMutation) RemovedNodeMessagesIDs() (ids []uint64) {
	for id := range m.removednode_messages {
		ids = append(ids, id)
	}
	return
}

// NodeMessagesIDs returns the "node_messages" edge IDs in the mutation.
func (m *SopNodeMutation) NodeMessagesIDs() (ids []uint64) {
	for id := range m.node_messages {
		ids = append(ids, id)
	}
	return
}

// ResetNodeMessages resets all changes to the "node_messages" edge.
func (m *SopNodeMutation) ResetNodeMessages() {
	m.node_messages = nil
	m.clearednode_messages = false
	m.removednode_messages = nil
}

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

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

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

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

// Type returns the node type of this mutation (SopNode).
func (m *SopNodeMutation) 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 *SopNodeMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, sopnode.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, sopnode.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, sopnode.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, sopnode.FieldDeletedAt)
	}
	if m.sop_stage != nil {
		fields = append(fields, sopnode.FieldStageID)
	}
	if m.parent_id != nil {
		fields = append(fields, sopnode.FieldParentID)
	}
	if m.name != nil {
		fields = append(fields, sopnode.FieldName)
	}
	if m.condition_type != nil {
		fields = append(fields, sopnode.FieldConditionType)
	}
	if m.condition_list != nil {
		fields = append(fields, sopnode.FieldConditionList)
	}
	if m.no_reply_condition != nil {
		fields = append(fields, sopnode.FieldNoReplyCondition)
	}
	if m.action_message != nil {
		fields = append(fields, sopnode.FieldActionMessage)
	}
	if m.action_label != nil {
		fields = append(fields, sopnode.FieldActionLabel)
	}
	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 *SopNodeMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case sopnode.FieldCreatedAt:
		return m.CreatedAt()
	case sopnode.FieldUpdatedAt:
		return m.UpdatedAt()
	case sopnode.FieldStatus:
		return m.Status()
	case sopnode.FieldDeletedAt:
		return m.DeletedAt()
	case sopnode.FieldStageID:
		return m.StageID()
	case sopnode.FieldParentID:
		return m.ParentID()
	case sopnode.FieldName:
		return m.Name()
	case sopnode.FieldConditionType:
		return m.ConditionType()
	case sopnode.FieldConditionList:
		return m.ConditionList()
	case sopnode.FieldNoReplyCondition:
		return m.NoReplyCondition()
	case sopnode.FieldActionMessage:
		return m.ActionMessage()
	case sopnode.FieldActionLabel:
		return m.ActionLabel()
	}
	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 *SopNodeMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case sopnode.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case sopnode.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case sopnode.FieldStatus:
		return m.OldStatus(ctx)
	case sopnode.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case sopnode.FieldStageID:
		return m.OldStageID(ctx)
	case sopnode.FieldParentID:
		return m.OldParentID(ctx)
	case sopnode.FieldName:
		return m.OldName(ctx)
	case sopnode.FieldConditionType:
		return m.OldConditionType(ctx)
	case sopnode.FieldConditionList:
		return m.OldConditionList(ctx)
	case sopnode.FieldNoReplyCondition:
		return m.OldNoReplyCondition(ctx)
	case sopnode.FieldActionMessage:
		return m.OldActionMessage(ctx)
	case sopnode.FieldActionLabel:
		return m.OldActionLabel(ctx)
	}
	return nil, fmt.Errorf("unknown SopNode 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 *SopNodeMutation) SetField(name string, value ent.Value) error {
	switch name {
	case sopnode.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 sopnode.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case sopnode.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case sopnode.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case sopnode.FieldStageID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStageID(v)
		return nil
	case sopnode.FieldParentID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetParentID(v)
		return nil
	case sopnode.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case sopnode.FieldConditionType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditionType(v)
		return nil
	case sopnode.FieldConditionList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditionList(v)
		return nil
	case sopnode.FieldNoReplyCondition:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNoReplyCondition(v)
		return nil
	case sopnode.FieldActionMessage:
		v, ok := value.([]custom_types.Action)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionMessage(v)
		return nil
	case sopnode.FieldActionLabel:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabel(v)
		return nil
	}
	return fmt.Errorf("unknown SopNode field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *SopNodeMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, sopnode.FieldStatus)
	}
	if m.addparent_id != nil {
		fields = append(fields, sopnode.FieldParentID)
	}
	if m.addcondition_type != nil {
		fields = append(fields, sopnode.FieldConditionType)
	}
	if m.addno_reply_condition != nil {
		fields = append(fields, sopnode.FieldNoReplyCondition)
	}
	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 *SopNodeMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case sopnode.FieldStatus:
		return m.AddedStatus()
	case sopnode.FieldParentID:
		return m.AddedParentID()
	case sopnode.FieldConditionType:
		return m.AddedConditionType()
	case sopnode.FieldNoReplyCondition:
		return m.AddedNoReplyCondition()
	}
	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 *SopNodeMutation) AddField(name string, value ent.Value) error {
	switch name {
	case sopnode.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case sopnode.FieldParentID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddParentID(v)
		return nil
	case sopnode.FieldConditionType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConditionType(v)
		return nil
	case sopnode.FieldNoReplyCondition:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNoReplyCondition(v)
		return nil
	}
	return fmt.Errorf("unknown SopNode numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *SopNodeMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(sopnode.FieldStatus) {
		fields = append(fields, sopnode.FieldStatus)
	}
	if m.FieldCleared(sopnode.FieldDeletedAt) {
		fields = append(fields, sopnode.FieldDeletedAt)
	}
	if m.FieldCleared(sopnode.FieldConditionList) {
		fields = append(fields, sopnode.FieldConditionList)
	}
	if m.FieldCleared(sopnode.FieldActionMessage) {
		fields = append(fields, sopnode.FieldActionMessage)
	}
	if m.FieldCleared(sopnode.FieldActionLabel) {
		fields = append(fields, sopnode.FieldActionLabel)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *SopNodeMutation) 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 *SopNodeMutation) ClearField(name string) error {
	switch name {
	case sopnode.FieldStatus:
		m.ClearStatus()
		return nil
	case sopnode.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case sopnode.FieldConditionList:
		m.ClearConditionList()
		return nil
	case sopnode.FieldActionMessage:
		m.ClearActionMessage()
		return nil
	case sopnode.FieldActionLabel:
		m.ClearActionLabel()
		return nil
	}
	return fmt.Errorf("unknown SopNode 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 *SopNodeMutation) ResetField(name string) error {
	switch name {
	case sopnode.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case sopnode.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case sopnode.FieldStatus:
		m.ResetStatus()
		return nil
	case sopnode.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case sopnode.FieldStageID:
		m.ResetStageID()
		return nil
	case sopnode.FieldParentID:
		m.ResetParentID()
		return nil
	case sopnode.FieldName:
		m.ResetName()
		return nil
	case sopnode.FieldConditionType:
		m.ResetConditionType()
		return nil
	case sopnode.FieldConditionList:
		m.ResetConditionList()
		return nil
	case sopnode.FieldNoReplyCondition:
		m.ResetNoReplyCondition()
		return nil
	case sopnode.FieldActionMessage:
		m.ResetActionMessage()
		return nil
	case sopnode.FieldActionLabel:
		m.ResetActionLabel()
		return nil
	}
	return fmt.Errorf("unknown SopNode field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *SopNodeMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.sop_stage != nil {
		edges = append(edges, sopnode.EdgeSopStage)
	}
	if m.node_messages != nil {
		edges = append(edges, sopnode.EdgeNodeMessages)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *SopNodeMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedsop_stage {
		edges = append(edges, sopnode.EdgeSopStage)
	}
	if m.clearednode_messages {
		edges = append(edges, sopnode.EdgeNodeMessages)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *SopNodeMutation) EdgeCleared(name string) bool {
	switch name {
	case sopnode.EdgeSopStage:
		return m.clearedsop_stage
	case sopnode.EdgeNodeMessages:
		return m.clearednode_messages
	}
	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 *SopNodeMutation) ClearEdge(name string) error {
	switch name {
	case sopnode.EdgeSopStage:
		m.ClearSopStage()
		return nil
	}
	return fmt.Errorf("unknown SopNode 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 *SopNodeMutation) ResetEdge(name string) error {
	switch name {
	case sopnode.EdgeSopStage:
		m.ResetSopStage()
		return nil
	case sopnode.EdgeNodeMessages:
		m.ResetNodeMessages()
		return nil
	}
	return fmt.Errorf("unknown SopNode edge %s", name)
}

// SopStageMutation represents an operation that mutates the SopStage nodes in the graph.
type SopStageMutation struct {
	config
	op                    Op
	typ                   string
	id                    *uint64
	created_at            *time.Time
	updated_at            *time.Time
	status                *uint8
	addstatus             *int8
	deleted_at            *time.Time
	name                  *string
	condition_type        *int
	addcondition_type     *int
	condition_operator    *int
	addcondition_operator *int
	condition_list        *[]custom_types.Condition
	appendcondition_list  []custom_types.Condition
	action_message        *[]custom_types.Action
	appendaction_message  []custom_types.Action
	action_label          *[]uint64
	appendaction_label    []uint64
	index_sort            *int
	addindex_sort         *int
	clearedFields         map[string]struct{}
	sop_task              *uint64
	clearedsop_task       bool
	stage_nodes           map[uint64]struct{}
	removedstage_nodes    map[uint64]struct{}
	clearedstage_nodes    bool
	stage_messages        map[uint64]struct{}
	removedstage_messages map[uint64]struct{}
	clearedstage_messages bool
	done                  bool
	oldValue              func(context.Context) (*SopStage, error)
	predicates            []predicate.SopStage
}

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

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

// newSopStageMutation creates new mutation for the SopStage entity.
func newSopStageMutation(c config, op Op, opts ...sopstageOption) *SopStageMutation {
	m := &SopStageMutation{
		config:        c,
		op:            op,
		typ:           TypeSopStage,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withSopStage sets the old SopStage of the mutation.
func withSopStage(node *SopStage) sopstageOption {
	return func(m *SopStageMutation) {
		m.oldValue = func(context.Context) (*SopStage, 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 SopStageMutation) 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 SopStageMutation) 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 SopStage entities.
func (m *SopStageMutation) SetID(id uint64) {
	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 *SopStageMutation) ID() (id uint64, 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 *SopStageMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().SopStage.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *SopStageMutation) 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 SopStage entity.
// If the SopStage 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 *SopStageMutation) 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 *SopStageMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *SopStageMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *SopStageMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[sopstage.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *SopStageMutation) StatusCleared() bool {
	_, ok := m.clearedFields[sopstage.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *SopStageMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, sopstage.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *SopStageMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *SopStageMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[sopstage.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *SopStageMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[sopstage.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *SopStageMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, sopstage.FieldDeletedAt)
}

// SetTaskID sets the "task_id" field.
func (m *SopStageMutation) SetTaskID(u uint64) {
	m.sop_task = &u
}

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

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

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

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

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

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

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

// SetConditionType sets the "condition_type" field.
func (m *SopStageMutation) SetConditionType(i int) {
	m.condition_type = &i
	m.addcondition_type = nil
}

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

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

// AddConditionType adds i to the "condition_type" field.
func (m *SopStageMutation) AddConditionType(i int) {
	if m.addcondition_type != nil {
		*m.addcondition_type += i
	} else {
		m.addcondition_type = &i
	}
}

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

// ResetConditionType resets all changes to the "condition_type" field.
func (m *SopStageMutation) ResetConditionType() {
	m.condition_type = nil
	m.addcondition_type = nil
}

// SetConditionOperator sets the "condition_operator" field.
func (m *SopStageMutation) SetConditionOperator(i int) {
	m.condition_operator = &i
	m.addcondition_operator = nil
}

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

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

// AddConditionOperator adds i to the "condition_operator" field.
func (m *SopStageMutation) AddConditionOperator(i int) {
	if m.addcondition_operator != nil {
		*m.addcondition_operator += i
	} else {
		m.addcondition_operator = &i
	}
}

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

// ResetConditionOperator resets all changes to the "condition_operator" field.
func (m *SopStageMutation) ResetConditionOperator() {
	m.condition_operator = nil
	m.addcondition_operator = nil
}

// SetConditionList sets the "condition_list" field.
func (m *SopStageMutation) SetConditionList(ct []custom_types.Condition) {
	m.condition_list = &ct
	m.appendcondition_list = nil
}

// ConditionList returns the value of the "condition_list" field in the mutation.
func (m *SopStageMutation) ConditionList() (r []custom_types.Condition, exists bool) {
	v := m.condition_list
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendConditionList adds ct to the "condition_list" field.
func (m *SopStageMutation) AppendConditionList(ct []custom_types.Condition) {
	m.appendcondition_list = append(m.appendcondition_list, ct...)
}

// AppendedConditionList returns the list of values that were appended to the "condition_list" field in this mutation.
func (m *SopStageMutation) AppendedConditionList() ([]custom_types.Condition, bool) {
	if len(m.appendcondition_list) == 0 {
		return nil, false
	}
	return m.appendcondition_list, true
}

// ResetConditionList resets all changes to the "condition_list" field.
func (m *SopStageMutation) ResetConditionList() {
	m.condition_list = nil
	m.appendcondition_list = nil
}

// SetActionMessage sets the "action_message" field.
func (m *SopStageMutation) SetActionMessage(ct []custom_types.Action) {
	m.action_message = &ct
	m.appendaction_message = nil
}

// ActionMessage returns the value of the "action_message" field in the mutation.
func (m *SopStageMutation) ActionMessage() (r []custom_types.Action, exists bool) {
	v := m.action_message
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendActionMessage adds ct to the "action_message" field.
func (m *SopStageMutation) AppendActionMessage(ct []custom_types.Action) {
	m.appendaction_message = append(m.appendaction_message, ct...)
}

// AppendedActionMessage returns the list of values that were appended to the "action_message" field in this mutation.
func (m *SopStageMutation) AppendedActionMessage() ([]custom_types.Action, bool) {
	if len(m.appendaction_message) == 0 {
		return nil, false
	}
	return m.appendaction_message, true
}

// ClearActionMessage clears the value of the "action_message" field.
func (m *SopStageMutation) ClearActionMessage() {
	m.action_message = nil
	m.appendaction_message = nil
	m.clearedFields[sopstage.FieldActionMessage] = struct{}{}
}

// ActionMessageCleared returns if the "action_message" field was cleared in this mutation.
func (m *SopStageMutation) ActionMessageCleared() bool {
	_, ok := m.clearedFields[sopstage.FieldActionMessage]
	return ok
}

// ResetActionMessage resets all changes to the "action_message" field.
func (m *SopStageMutation) ResetActionMessage() {
	m.action_message = nil
	m.appendaction_message = nil
	delete(m.clearedFields, sopstage.FieldActionMessage)
}

// SetActionLabel sets the "action_label" field.
func (m *SopStageMutation) SetActionLabel(u []uint64) {
	m.action_label = &u
	m.appendaction_label = nil
}

// ActionLabel returns the value of the "action_label" field in the mutation.
func (m *SopStageMutation) ActionLabel() (r []uint64, exists bool) {
	v := m.action_label
	if v == nil {
		return
	}
	return *v, true
}

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

// AppendActionLabel adds u to the "action_label" field.
func (m *SopStageMutation) AppendActionLabel(u []uint64) {
	m.appendaction_label = append(m.appendaction_label, u...)
}

// AppendedActionLabel returns the list of values that were appended to the "action_label" field in this mutation.
func (m *SopStageMutation) AppendedActionLabel() ([]uint64, bool) {
	if len(m.appendaction_label) == 0 {
		return nil, false
	}
	return m.appendaction_label, true
}

// ClearActionLabel clears the value of the "action_label" field.
func (m *SopStageMutation) ClearActionLabel() {
	m.action_label = nil
	m.appendaction_label = nil
	m.clearedFields[sopstage.FieldActionLabel] = struct{}{}
}

// ActionLabelCleared returns if the "action_label" field was cleared in this mutation.
func (m *SopStageMutation) ActionLabelCleared() bool {
	_, ok := m.clearedFields[sopstage.FieldActionLabel]
	return ok
}

// ResetActionLabel resets all changes to the "action_label" field.
func (m *SopStageMutation) ResetActionLabel() {
	m.action_label = nil
	m.appendaction_label = nil
	delete(m.clearedFields, sopstage.FieldActionLabel)
}

// SetIndexSort sets the "index_sort" field.
func (m *SopStageMutation) SetIndexSort(i int) {
	m.index_sort = &i
	m.addindex_sort = nil
}

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

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

// AddIndexSort adds i to the "index_sort" field.
func (m *SopStageMutation) AddIndexSort(i int) {
	if m.addindex_sort != nil {
		*m.addindex_sort += i
	} else {
		m.addindex_sort = &i
	}
}

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

// ClearIndexSort clears the value of the "index_sort" field.
func (m *SopStageMutation) ClearIndexSort() {
	m.index_sort = nil
	m.addindex_sort = nil
	m.clearedFields[sopstage.FieldIndexSort] = struct{}{}
}

// IndexSortCleared returns if the "index_sort" field was cleared in this mutation.
func (m *SopStageMutation) IndexSortCleared() bool {
	_, ok := m.clearedFields[sopstage.FieldIndexSort]
	return ok
}

// ResetIndexSort resets all changes to the "index_sort" field.
func (m *SopStageMutation) ResetIndexSort() {
	m.index_sort = nil
	m.addindex_sort = nil
	delete(m.clearedFields, sopstage.FieldIndexSort)
}

// SetSopTaskID sets the "sop_task" edge to the SopTask entity by id.
func (m *SopStageMutation) SetSopTaskID(id uint64) {
	m.sop_task = &id
}

// ClearSopTask clears the "sop_task" edge to the SopTask entity.
func (m *SopStageMutation) ClearSopTask() {
	m.clearedsop_task = true
	m.clearedFields[sopstage.FieldTaskID] = struct{}{}
}

// SopTaskCleared reports if the "sop_task" edge to the SopTask entity was cleared.
func (m *SopStageMutation) SopTaskCleared() bool {
	return m.clearedsop_task
}

// SopTaskID returns the "sop_task" edge ID in the mutation.
func (m *SopStageMutation) SopTaskID() (id uint64, exists bool) {
	if m.sop_task != nil {
		return *m.sop_task, true
	}
	return
}

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

// ResetSopTask resets all changes to the "sop_task" edge.
func (m *SopStageMutation) ResetSopTask() {
	m.sop_task = nil
	m.clearedsop_task = false
}

// AddStageNodeIDs adds the "stage_nodes" edge to the SopNode entity by ids.
func (m *SopStageMutation) AddStageNodeIDs(ids ...uint64) {
	if m.stage_nodes == nil {
		m.stage_nodes = make(map[uint64]struct{})
	}
	for i := range ids {
		m.stage_nodes[ids[i]] = struct{}{}
	}
}

// ClearStageNodes clears the "stage_nodes" edge to the SopNode entity.
func (m *SopStageMutation) ClearStageNodes() {
	m.clearedstage_nodes = true
}

// StageNodesCleared reports if the "stage_nodes" edge to the SopNode entity was cleared.
func (m *SopStageMutation) StageNodesCleared() bool {
	return m.clearedstage_nodes
}

// RemoveStageNodeIDs removes the "stage_nodes" edge to the SopNode entity by IDs.
func (m *SopStageMutation) RemoveStageNodeIDs(ids ...uint64) {
	if m.removedstage_nodes == nil {
		m.removedstage_nodes = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.stage_nodes, ids[i])
		m.removedstage_nodes[ids[i]] = struct{}{}
	}
}

// RemovedStageNodes returns the removed IDs of the "stage_nodes" edge to the SopNode entity.
func (m *SopStageMutation) RemovedStageNodesIDs() (ids []uint64) {
	for id := range m.removedstage_nodes {
		ids = append(ids, id)
	}
	return
}

// StageNodesIDs returns the "stage_nodes" edge IDs in the mutation.
func (m *SopStageMutation) StageNodesIDs() (ids []uint64) {
	for id := range m.stage_nodes {
		ids = append(ids, id)
	}
	return
}

// ResetStageNodes resets all changes to the "stage_nodes" edge.
func (m *SopStageMutation) ResetStageNodes() {
	m.stage_nodes = nil
	m.clearedstage_nodes = false
	m.removedstage_nodes = nil
}

// AddStageMessageIDs adds the "stage_messages" edge to the MessageRecords entity by ids.
func (m *SopStageMutation) AddStageMessageIDs(ids ...uint64) {
	if m.stage_messages == nil {
		m.stage_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		m.stage_messages[ids[i]] = struct{}{}
	}
}

// ClearStageMessages clears the "stage_messages" edge to the MessageRecords entity.
func (m *SopStageMutation) ClearStageMessages() {
	m.clearedstage_messages = true
}

// StageMessagesCleared reports if the "stage_messages" edge to the MessageRecords entity was cleared.
func (m *SopStageMutation) StageMessagesCleared() bool {
	return m.clearedstage_messages
}

// RemoveStageMessageIDs removes the "stage_messages" edge to the MessageRecords entity by IDs.
func (m *SopStageMutation) RemoveStageMessageIDs(ids ...uint64) {
	if m.removedstage_messages == nil {
		m.removedstage_messages = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.stage_messages, ids[i])
		m.removedstage_messages[ids[i]] = struct{}{}
	}
}

// RemovedStageMessages returns the removed IDs of the "stage_messages" edge to the MessageRecords entity.
func (m *SopStageMutation) RemovedStageMessagesIDs() (ids []uint64) {
	for id := range m.removedstage_messages {
		ids = append(ids, id)
	}
	return
}

// StageMessagesIDs returns the "stage_messages" edge IDs in the mutation.
func (m *SopStageMutation) StageMessagesIDs() (ids []uint64) {
	for id := range m.stage_messages {
		ids = append(ids, id)
	}
	return
}

// ResetStageMessages resets all changes to the "stage_messages" edge.
func (m *SopStageMutation) ResetStageMessages() {
	m.stage_messages = nil
	m.clearedstage_messages = false
	m.removedstage_messages = nil
}

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

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

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

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

// Type returns the node type of this mutation (SopStage).
func (m *SopStageMutation) 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 *SopStageMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, sopstage.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, sopstage.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, sopstage.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, sopstage.FieldDeletedAt)
	}
	if m.sop_task != nil {
		fields = append(fields, sopstage.FieldTaskID)
	}
	if m.name != nil {
		fields = append(fields, sopstage.FieldName)
	}
	if m.condition_type != nil {
		fields = append(fields, sopstage.FieldConditionType)
	}
	if m.condition_operator != nil {
		fields = append(fields, sopstage.FieldConditionOperator)
	}
	if m.condition_list != nil {
		fields = append(fields, sopstage.FieldConditionList)
	}
	if m.action_message != nil {
		fields = append(fields, sopstage.FieldActionMessage)
	}
	if m.action_label != nil {
		fields = append(fields, sopstage.FieldActionLabel)
	}
	if m.index_sort != nil {
		fields = append(fields, sopstage.FieldIndexSort)
	}
	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 *SopStageMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case sopstage.FieldCreatedAt:
		return m.CreatedAt()
	case sopstage.FieldUpdatedAt:
		return m.UpdatedAt()
	case sopstage.FieldStatus:
		return m.Status()
	case sopstage.FieldDeletedAt:
		return m.DeletedAt()
	case sopstage.FieldTaskID:
		return m.TaskID()
	case sopstage.FieldName:
		return m.Name()
	case sopstage.FieldConditionType:
		return m.ConditionType()
	case sopstage.FieldConditionOperator:
		return m.ConditionOperator()
	case sopstage.FieldConditionList:
		return m.ConditionList()
	case sopstage.FieldActionMessage:
		return m.ActionMessage()
	case sopstage.FieldActionLabel:
		return m.ActionLabel()
	case sopstage.FieldIndexSort:
		return m.IndexSort()
	}
	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 *SopStageMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case sopstage.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case sopstage.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case sopstage.FieldStatus:
		return m.OldStatus(ctx)
	case sopstage.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case sopstage.FieldTaskID:
		return m.OldTaskID(ctx)
	case sopstage.FieldName:
		return m.OldName(ctx)
	case sopstage.FieldConditionType:
		return m.OldConditionType(ctx)
	case sopstage.FieldConditionOperator:
		return m.OldConditionOperator(ctx)
	case sopstage.FieldConditionList:
		return m.OldConditionList(ctx)
	case sopstage.FieldActionMessage:
		return m.OldActionMessage(ctx)
	case sopstage.FieldActionLabel:
		return m.OldActionLabel(ctx)
	case sopstage.FieldIndexSort:
		return m.OldIndexSort(ctx)
	}
	return nil, fmt.Errorf("unknown SopStage 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 *SopStageMutation) SetField(name string, value ent.Value) error {
	switch name {
	case sopstage.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 sopstage.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case sopstage.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case sopstage.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case sopstage.FieldTaskID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTaskID(v)
		return nil
	case sopstage.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case sopstage.FieldConditionType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditionType(v)
		return nil
	case sopstage.FieldConditionOperator:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditionOperator(v)
		return nil
	case sopstage.FieldConditionList:
		v, ok := value.([]custom_types.Condition)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditionList(v)
		return nil
	case sopstage.FieldActionMessage:
		v, ok := value.([]custom_types.Action)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionMessage(v)
		return nil
	case sopstage.FieldActionLabel:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabel(v)
		return nil
	case sopstage.FieldIndexSort:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIndexSort(v)
		return nil
	}
	return fmt.Errorf("unknown SopStage field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *SopStageMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, sopstage.FieldStatus)
	}
	if m.addcondition_type != nil {
		fields = append(fields, sopstage.FieldConditionType)
	}
	if m.addcondition_operator != nil {
		fields = append(fields, sopstage.FieldConditionOperator)
	}
	if m.addindex_sort != nil {
		fields = append(fields, sopstage.FieldIndexSort)
	}
	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 *SopStageMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case sopstage.FieldStatus:
		return m.AddedStatus()
	case sopstage.FieldConditionType:
		return m.AddedConditionType()
	case sopstage.FieldConditionOperator:
		return m.AddedConditionOperator()
	case sopstage.FieldIndexSort:
		return m.AddedIndexSort()
	}
	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 *SopStageMutation) AddField(name string, value ent.Value) error {
	switch name {
	case sopstage.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case sopstage.FieldConditionType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConditionType(v)
		return nil
	case sopstage.FieldConditionOperator:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConditionOperator(v)
		return nil
	case sopstage.FieldIndexSort:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddIndexSort(v)
		return nil
	}
	return fmt.Errorf("unknown SopStage numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *SopStageMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(sopstage.FieldStatus) {
		fields = append(fields, sopstage.FieldStatus)
	}
	if m.FieldCleared(sopstage.FieldDeletedAt) {
		fields = append(fields, sopstage.FieldDeletedAt)
	}
	if m.FieldCleared(sopstage.FieldActionMessage) {
		fields = append(fields, sopstage.FieldActionMessage)
	}
	if m.FieldCleared(sopstage.FieldActionLabel) {
		fields = append(fields, sopstage.FieldActionLabel)
	}
	if m.FieldCleared(sopstage.FieldIndexSort) {
		fields = append(fields, sopstage.FieldIndexSort)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *SopStageMutation) 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 *SopStageMutation) ClearField(name string) error {
	switch name {
	case sopstage.FieldStatus:
		m.ClearStatus()
		return nil
	case sopstage.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case sopstage.FieldActionMessage:
		m.ClearActionMessage()
		return nil
	case sopstage.FieldActionLabel:
		m.ClearActionLabel()
		return nil
	case sopstage.FieldIndexSort:
		m.ClearIndexSort()
		return nil
	}
	return fmt.Errorf("unknown SopStage 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 *SopStageMutation) ResetField(name string) error {
	switch name {
	case sopstage.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case sopstage.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case sopstage.FieldStatus:
		m.ResetStatus()
		return nil
	case sopstage.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case sopstage.FieldTaskID:
		m.ResetTaskID()
		return nil
	case sopstage.FieldName:
		m.ResetName()
		return nil
	case sopstage.FieldConditionType:
		m.ResetConditionType()
		return nil
	case sopstage.FieldConditionOperator:
		m.ResetConditionOperator()
		return nil
	case sopstage.FieldConditionList:
		m.ResetConditionList()
		return nil
	case sopstage.FieldActionMessage:
		m.ResetActionMessage()
		return nil
	case sopstage.FieldActionLabel:
		m.ResetActionLabel()
		return nil
	case sopstage.FieldIndexSort:
		m.ResetIndexSort()
		return nil
	}
	return fmt.Errorf("unknown SopStage field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *SopStageMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.sop_task != nil {
		edges = append(edges, sopstage.EdgeSopTask)
	}
	if m.stage_nodes != nil {
		edges = append(edges, sopstage.EdgeStageNodes)
	}
	if m.stage_messages != nil {
		edges = append(edges, sopstage.EdgeStageMessages)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *SopStageMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case sopstage.EdgeSopTask:
		if id := m.sop_task; id != nil {
			return []ent.Value{*id}
		}
	case sopstage.EdgeStageNodes:
		ids := make([]ent.Value, 0, len(m.stage_nodes))
		for id := range m.stage_nodes {
			ids = append(ids, id)
		}
		return ids
	case sopstage.EdgeStageMessages:
		ids := make([]ent.Value, 0, len(m.stage_messages))
		for id := range m.stage_messages {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *SopStageMutation) RemovedEdges() []string {
	edges := make([]string, 0, 3)
	if m.removedstage_nodes != nil {
		edges = append(edges, sopstage.EdgeStageNodes)
	}
	if m.removedstage_messages != nil {
		edges = append(edges, sopstage.EdgeStageMessages)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *SopStageMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedsop_task {
		edges = append(edges, sopstage.EdgeSopTask)
	}
	if m.clearedstage_nodes {
		edges = append(edges, sopstage.EdgeStageNodes)
	}
	if m.clearedstage_messages {
		edges = append(edges, sopstage.EdgeStageMessages)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *SopStageMutation) EdgeCleared(name string) bool {
	switch name {
	case sopstage.EdgeSopTask:
		return m.clearedsop_task
	case sopstage.EdgeStageNodes:
		return m.clearedstage_nodes
	case sopstage.EdgeStageMessages:
		return m.clearedstage_messages
	}
	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 *SopStageMutation) ClearEdge(name string) error {
	switch name {
	case sopstage.EdgeSopTask:
		m.ClearSopTask()
		return nil
	}
	return fmt.Errorf("unknown SopStage 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 *SopStageMutation) ResetEdge(name string) error {
	switch name {
	case sopstage.EdgeSopTask:
		m.ResetSopTask()
		return nil
	case sopstage.EdgeStageNodes:
		m.ResetStageNodes()
		return nil
	case sopstage.EdgeStageMessages:
		m.ResetStageMessages()
		return nil
	}
	return fmt.Errorf("unknown SopStage edge %s", name)
}

// SopTaskMutation represents an operation that mutates the SopTask nodes in the graph.
type SopTaskMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uint64
	created_at          *time.Time
	updated_at          *time.Time
	status              *uint8
	addstatus           *int8
	deleted_at          *time.Time
	name                *string
	bot_wxid_list       *[]string
	appendbot_wxid_list []string
	_type               *int
	add_type            *int
	plan_start_time     *time.Time
	plan_end_time       *time.Time
	creator_id          *string
	clearedFields       map[string]struct{}
	task_stages         map[uint64]struct{}
	removedtask_stages  map[uint64]struct{}
	clearedtask_stages  bool
	done                bool
	oldValue            func(context.Context) (*SopTask, error)
	predicates          []predicate.SopTask
}

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

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

// newSopTaskMutation creates new mutation for the SopTask entity.
func newSopTaskMutation(c config, op Op, opts ...soptaskOption) *SopTaskMutation {
	m := &SopTaskMutation{
		config:        c,
		op:            op,
		typ:           TypeSopTask,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withSopTask sets the old SopTask of the mutation.
func withSopTask(node *SopTask) soptaskOption {
	return func(m *SopTaskMutation) {
		m.oldValue = func(context.Context) (*SopTask, 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 SopTaskMutation) 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 SopTaskMutation) 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 SopTask entities.
func (m *SopTaskMutation) SetID(id uint64) {
	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 *SopTaskMutation) ID() (id uint64, 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 *SopTaskMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().SopTask.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *SopTaskMutation) 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 SopTask entity.
// If the SopTask 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 *SopTaskMutation) 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 *SopTaskMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *SopTaskMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *SopTaskMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[soptask.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *SopTaskMutation) StatusCleared() bool {
	_, ok := m.clearedFields[soptask.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *SopTaskMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, soptask.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *SopTaskMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *SopTaskMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[soptask.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *SopTaskMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[soptask.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *SopTaskMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, soptask.FieldDeletedAt)
}

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

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

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

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

// SetBotWxidList sets the "bot_wxid_list" field.
func (m *SopTaskMutation) SetBotWxidList(s []string) {
	m.bot_wxid_list = &s
	m.appendbot_wxid_list = nil
}

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

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

// AppendBotWxidList adds s to the "bot_wxid_list" field.
func (m *SopTaskMutation) AppendBotWxidList(s []string) {
	m.appendbot_wxid_list = append(m.appendbot_wxid_list, s...)
}

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

// ClearBotWxidList clears the value of the "bot_wxid_list" field.
func (m *SopTaskMutation) ClearBotWxidList() {
	m.bot_wxid_list = nil
	m.appendbot_wxid_list = nil
	m.clearedFields[soptask.FieldBotWxidList] = struct{}{}
}

// BotWxidListCleared returns if the "bot_wxid_list" field was cleared in this mutation.
func (m *SopTaskMutation) BotWxidListCleared() bool {
	_, ok := m.clearedFields[soptask.FieldBotWxidList]
	return ok
}

// ResetBotWxidList resets all changes to the "bot_wxid_list" field.
func (m *SopTaskMutation) ResetBotWxidList() {
	m.bot_wxid_list = nil
	m.appendbot_wxid_list = nil
	delete(m.clearedFields, soptask.FieldBotWxidList)
}

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

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

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

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

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

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

// SetPlanStartTime sets the "plan_start_time" field.
func (m *SopTaskMutation) SetPlanStartTime(t time.Time) {
	m.plan_start_time = &t
}

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

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

// ClearPlanStartTime clears the value of the "plan_start_time" field.
func (m *SopTaskMutation) ClearPlanStartTime() {
	m.plan_start_time = nil
	m.clearedFields[soptask.FieldPlanStartTime] = struct{}{}
}

// PlanStartTimeCleared returns if the "plan_start_time" field was cleared in this mutation.
func (m *SopTaskMutation) PlanStartTimeCleared() bool {
	_, ok := m.clearedFields[soptask.FieldPlanStartTime]
	return ok
}

// ResetPlanStartTime resets all changes to the "plan_start_time" field.
func (m *SopTaskMutation) ResetPlanStartTime() {
	m.plan_start_time = nil
	delete(m.clearedFields, soptask.FieldPlanStartTime)
}

// SetPlanEndTime sets the "plan_end_time" field.
func (m *SopTaskMutation) SetPlanEndTime(t time.Time) {
	m.plan_end_time = &t
}

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

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

// ClearPlanEndTime clears the value of the "plan_end_time" field.
func (m *SopTaskMutation) ClearPlanEndTime() {
	m.plan_end_time = nil
	m.clearedFields[soptask.FieldPlanEndTime] = struct{}{}
}

// PlanEndTimeCleared returns if the "plan_end_time" field was cleared in this mutation.
func (m *SopTaskMutation) PlanEndTimeCleared() bool {
	_, ok := m.clearedFields[soptask.FieldPlanEndTime]
	return ok
}

// ResetPlanEndTime resets all changes to the "plan_end_time" field.
func (m *SopTaskMutation) ResetPlanEndTime() {
	m.plan_end_time = nil
	delete(m.clearedFields, soptask.FieldPlanEndTime)
}

// SetCreatorID sets the "creator_id" field.
func (m *SopTaskMutation) SetCreatorID(s string) {
	m.creator_id = &s
}

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

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

// ClearCreatorID clears the value of the "creator_id" field.
func (m *SopTaskMutation) ClearCreatorID() {
	m.creator_id = nil
	m.clearedFields[soptask.FieldCreatorID] = struct{}{}
}

// CreatorIDCleared returns if the "creator_id" field was cleared in this mutation.
func (m *SopTaskMutation) CreatorIDCleared() bool {
	_, ok := m.clearedFields[soptask.FieldCreatorID]
	return ok
}

// ResetCreatorID resets all changes to the "creator_id" field.
func (m *SopTaskMutation) ResetCreatorID() {
	m.creator_id = nil
	delete(m.clearedFields, soptask.FieldCreatorID)
}

// AddTaskStageIDs adds the "task_stages" edge to the SopStage entity by ids.
func (m *SopTaskMutation) AddTaskStageIDs(ids ...uint64) {
	if m.task_stages == nil {
		m.task_stages = make(map[uint64]struct{})
	}
	for i := range ids {
		m.task_stages[ids[i]] = struct{}{}
	}
}

// ClearTaskStages clears the "task_stages" edge to the SopStage entity.
func (m *SopTaskMutation) ClearTaskStages() {
	m.clearedtask_stages = true
}

// TaskStagesCleared reports if the "task_stages" edge to the SopStage entity was cleared.
func (m *SopTaskMutation) TaskStagesCleared() bool {
	return m.clearedtask_stages
}

// RemoveTaskStageIDs removes the "task_stages" edge to the SopStage entity by IDs.
func (m *SopTaskMutation) RemoveTaskStageIDs(ids ...uint64) {
	if m.removedtask_stages == nil {
		m.removedtask_stages = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.task_stages, ids[i])
		m.removedtask_stages[ids[i]] = struct{}{}
	}
}

// RemovedTaskStages returns the removed IDs of the "task_stages" edge to the SopStage entity.
func (m *SopTaskMutation) RemovedTaskStagesIDs() (ids []uint64) {
	for id := range m.removedtask_stages {
		ids = append(ids, id)
	}
	return
}

// TaskStagesIDs returns the "task_stages" edge IDs in the mutation.
func (m *SopTaskMutation) TaskStagesIDs() (ids []uint64) {
	for id := range m.task_stages {
		ids = append(ids, id)
	}
	return
}

// ResetTaskStages resets all changes to the "task_stages" edge.
func (m *SopTaskMutation) ResetTaskStages() {
	m.task_stages = nil
	m.clearedtask_stages = false
	m.removedtask_stages = nil
}

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

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

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

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

// Type returns the node type of this mutation (SopTask).
func (m *SopTaskMutation) 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 *SopTaskMutation) Fields() []string {
	fields := make([]string, 0, 10)
	if m.created_at != nil {
		fields = append(fields, soptask.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, soptask.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, soptask.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, soptask.FieldDeletedAt)
	}
	if m.name != nil {
		fields = append(fields, soptask.FieldName)
	}
	if m.bot_wxid_list != nil {
		fields = append(fields, soptask.FieldBotWxidList)
	}
	if m._type != nil {
		fields = append(fields, soptask.FieldType)
	}
	if m.plan_start_time != nil {
		fields = append(fields, soptask.FieldPlanStartTime)
	}
	if m.plan_end_time != nil {
		fields = append(fields, soptask.FieldPlanEndTime)
	}
	if m.creator_id != nil {
		fields = append(fields, soptask.FieldCreatorID)
	}
	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 *SopTaskMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case soptask.FieldCreatedAt:
		return m.CreatedAt()
	case soptask.FieldUpdatedAt:
		return m.UpdatedAt()
	case soptask.FieldStatus:
		return m.Status()
	case soptask.FieldDeletedAt:
		return m.DeletedAt()
	case soptask.FieldName:
		return m.Name()
	case soptask.FieldBotWxidList:
		return m.BotWxidList()
	case soptask.FieldType:
		return m.GetType()
	case soptask.FieldPlanStartTime:
		return m.PlanStartTime()
	case soptask.FieldPlanEndTime:
		return m.PlanEndTime()
	case soptask.FieldCreatorID:
		return m.CreatorID()
	}
	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 *SopTaskMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case soptask.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case soptask.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case soptask.FieldStatus:
		return m.OldStatus(ctx)
	case soptask.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case soptask.FieldName:
		return m.OldName(ctx)
	case soptask.FieldBotWxidList:
		return m.OldBotWxidList(ctx)
	case soptask.FieldType:
		return m.OldType(ctx)
	case soptask.FieldPlanStartTime:
		return m.OldPlanStartTime(ctx)
	case soptask.FieldPlanEndTime:
		return m.OldPlanEndTime(ctx)
	case soptask.FieldCreatorID:
		return m.OldCreatorID(ctx)
	}
	return nil, fmt.Errorf("unknown SopTask 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 *SopTaskMutation) SetField(name string, value ent.Value) error {
	switch name {
	case soptask.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 soptask.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case soptask.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case soptask.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case soptask.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case soptask.FieldBotWxidList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotWxidList(v)
		return nil
	case soptask.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case soptask.FieldPlanStartTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPlanStartTime(v)
		return nil
	case soptask.FieldPlanEndTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPlanEndTime(v)
		return nil
	case soptask.FieldCreatorID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatorID(v)
		return nil
	}
	return fmt.Errorf("unknown SopTask field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *SopTaskMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(soptask.FieldStatus) {
		fields = append(fields, soptask.FieldStatus)
	}
	if m.FieldCleared(soptask.FieldDeletedAt) {
		fields = append(fields, soptask.FieldDeletedAt)
	}
	if m.FieldCleared(soptask.FieldBotWxidList) {
		fields = append(fields, soptask.FieldBotWxidList)
	}
	if m.FieldCleared(soptask.FieldPlanStartTime) {
		fields = append(fields, soptask.FieldPlanStartTime)
	}
	if m.FieldCleared(soptask.FieldPlanEndTime) {
		fields = append(fields, soptask.FieldPlanEndTime)
	}
	if m.FieldCleared(soptask.FieldCreatorID) {
		fields = append(fields, soptask.FieldCreatorID)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *SopTaskMutation) 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 *SopTaskMutation) ClearField(name string) error {
	switch name {
	case soptask.FieldStatus:
		m.ClearStatus()
		return nil
	case soptask.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case soptask.FieldBotWxidList:
		m.ClearBotWxidList()
		return nil
	case soptask.FieldPlanStartTime:
		m.ClearPlanStartTime()
		return nil
	case soptask.FieldPlanEndTime:
		m.ClearPlanEndTime()
		return nil
	case soptask.FieldCreatorID:
		m.ClearCreatorID()
		return nil
	}
	return fmt.Errorf("unknown SopTask 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 *SopTaskMutation) ResetField(name string) error {
	switch name {
	case soptask.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case soptask.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case soptask.FieldStatus:
		m.ResetStatus()
		return nil
	case soptask.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case soptask.FieldName:
		m.ResetName()
		return nil
	case soptask.FieldBotWxidList:
		m.ResetBotWxidList()
		return nil
	case soptask.FieldType:
		m.ResetType()
		return nil
	case soptask.FieldPlanStartTime:
		m.ResetPlanStartTime()
		return nil
	case soptask.FieldPlanEndTime:
		m.ResetPlanEndTime()
		return nil
	case soptask.FieldCreatorID:
		m.ResetCreatorID()
		return nil
	}
	return fmt.Errorf("unknown SopTask field %s", name)
}

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

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

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

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

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

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

// WxMutation represents an operation that mutates the Wx nodes in the graph.
type WxMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	status        *uint8
	addstatus     *int8
	deleted_at    *time.Time
	port          *string
	process_id    *string
	callback      *string
	wxid          *string
	account       *string
	nickname      *string
	tel           *string
	head_big      *string
	clearedFields map[string]struct{}
	server        *uint64
	clearedserver bool
	done          bool
	oldValue      func(context.Context) (*Wx, error)
	predicates    []predicate.Wx
}

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

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

// newWxMutation creates new mutation for the Wx entity.
func newWxMutation(c config, op Op, opts ...wxOption) *WxMutation {
	m := &WxMutation{
		config:        c,
		op:            op,
		typ:           TypeWx,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWx sets the old Wx of the mutation.
func withWx(node *Wx) wxOption {
	return func(m *WxMutation) {
		m.oldValue = func(context.Context) (*Wx, 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 WxMutation) 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 WxMutation) 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 Wx entities.
func (m *WxMutation) SetID(id uint64) {
	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 *WxMutation) ID() (id uint64, 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 *WxMutation) IDs(ctx context.Context) ([]uint64, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint64{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Wx.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

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

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *WxMutation) 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 Wx entity.
// If the Wx 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 *WxMutation) 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 *WxMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetStatus sets the "status" field.
func (m *WxMutation) SetStatus(u uint8) {
	m.status = &u
	m.addstatus = nil
}

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

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

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

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

// ClearStatus clears the value of the "status" field.
func (m *WxMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[wx.FieldStatus] = struct{}{}
}

// StatusCleared returns if the "status" field was cleared in this mutation.
func (m *WxMutation) StatusCleared() bool {
	_, ok := m.clearedFields[wx.FieldStatus]
	return ok
}

// ResetStatus resets all changes to the "status" field.
func (m *WxMutation) ResetStatus() {
	m.status = nil
	m.addstatus = nil
	delete(m.clearedFields, wx.FieldStatus)
}

// SetDeletedAt sets the "deleted_at" field.
func (m *WxMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *WxMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[wx.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *WxMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[wx.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *WxMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, wx.FieldDeletedAt)
}

// SetServerID sets the "server_id" field.
func (m *WxMutation) SetServerID(u uint64) {
	m.server = &u
}

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

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

// ClearServerID clears the value of the "server_id" field.
func (m *WxMutation) ClearServerID() {
	m.server = nil
	m.clearedFields[wx.FieldServerID] = struct{}{}
}

// ServerIDCleared returns if the "server_id" field was cleared in this mutation.
func (m *WxMutation) ServerIDCleared() bool {
	_, ok := m.clearedFields[wx.FieldServerID]
	return ok
}

// ResetServerID resets all changes to the "server_id" field.
func (m *WxMutation) ResetServerID() {
	m.server = nil
	delete(m.clearedFields, wx.FieldServerID)
}

// SetPort sets the "port" field.
func (m *WxMutation) SetPort(s string) {
	m.port = &s
}

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

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

// ResetPort resets all changes to the "port" field.
func (m *WxMutation) ResetPort() {
	m.port = nil
}

// SetProcessID sets the "process_id" field.
func (m *WxMutation) SetProcessID(s string) {
	m.process_id = &s
}

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

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

// ResetProcessID resets all changes to the "process_id" field.
func (m *WxMutation) ResetProcessID() {
	m.process_id = nil
}

// SetCallback sets the "callback" field.
func (m *WxMutation) SetCallback(s string) {
	m.callback = &s
}

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

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

// ResetCallback resets all changes to the "callback" field.
func (m *WxMutation) ResetCallback() {
	m.callback = nil
}

// SetWxid sets the "wxid" field.
func (m *WxMutation) SetWxid(s string) {
	m.wxid = &s
}

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

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

// ResetWxid resets all changes to the "wxid" field.
func (m *WxMutation) ResetWxid() {
	m.wxid = nil
}

// SetAccount sets the "account" field.
func (m *WxMutation) SetAccount(s string) {
	m.account = &s
}

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

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

// ResetAccount resets all changes to the "account" field.
func (m *WxMutation) ResetAccount() {
	m.account = nil
}

// SetNickname sets the "nickname" field.
func (m *WxMutation) SetNickname(s string) {
	m.nickname = &s
}

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

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

// ResetNickname resets all changes to the "nickname" field.
func (m *WxMutation) ResetNickname() {
	m.nickname = nil
}

// SetTel sets the "tel" field.
func (m *WxMutation) SetTel(s string) {
	m.tel = &s
}

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

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

// ResetTel resets all changes to the "tel" field.
func (m *WxMutation) ResetTel() {
	m.tel = nil
}

// SetHeadBig sets the "head_big" field.
func (m *WxMutation) SetHeadBig(s string) {
	m.head_big = &s
}

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

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

// ResetHeadBig resets all changes to the "head_big" field.
func (m *WxMutation) ResetHeadBig() {
	m.head_big = nil
}

// ClearServer clears the "server" edge to the Server entity.
func (m *WxMutation) ClearServer() {
	m.clearedserver = true
	m.clearedFields[wx.FieldServerID] = struct{}{}
}

// ServerCleared reports if the "server" edge to the Server entity was cleared.
func (m *WxMutation) ServerCleared() bool {
	return m.ServerIDCleared() || m.clearedserver
}

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

// ResetServer resets all changes to the "server" edge.
func (m *WxMutation) ResetServer() {
	m.server = nil
	m.clearedserver = false
}

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

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

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

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

// Type returns the node type of this mutation (Wx).
func (m *WxMutation) 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 *WxMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.created_at != nil {
		fields = append(fields, wx.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wx.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, wx.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, wx.FieldDeletedAt)
	}
	if m.server != nil {
		fields = append(fields, wx.FieldServerID)
	}
	if m.port != nil {
		fields = append(fields, wx.FieldPort)
	}
	if m.process_id != nil {
		fields = append(fields, wx.FieldProcessID)
	}
	if m.callback != nil {
		fields = append(fields, wx.FieldCallback)
	}
	if m.wxid != nil {
		fields = append(fields, wx.FieldWxid)
	}
	if m.account != nil {
		fields = append(fields, wx.FieldAccount)
	}
	if m.nickname != nil {
		fields = append(fields, wx.FieldNickname)
	}
	if m.tel != nil {
		fields = append(fields, wx.FieldTel)
	}
	if m.head_big != nil {
		fields = append(fields, wx.FieldHeadBig)
	}
	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 *WxMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wx.FieldCreatedAt:
		return m.CreatedAt()
	case wx.FieldUpdatedAt:
		return m.UpdatedAt()
	case wx.FieldStatus:
		return m.Status()
	case wx.FieldDeletedAt:
		return m.DeletedAt()
	case wx.FieldServerID:
		return m.ServerID()
	case wx.FieldPort:
		return m.Port()
	case wx.FieldProcessID:
		return m.ProcessID()
	case wx.FieldCallback:
		return m.Callback()
	case wx.FieldWxid:
		return m.Wxid()
	case wx.FieldAccount:
		return m.Account()
	case wx.FieldNickname:
		return m.Nickname()
	case wx.FieldTel:
		return m.Tel()
	case wx.FieldHeadBig:
		return m.HeadBig()
	}
	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 *WxMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wx.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wx.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wx.FieldStatus:
		return m.OldStatus(ctx)
	case wx.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case wx.FieldServerID:
		return m.OldServerID(ctx)
	case wx.FieldPort:
		return m.OldPort(ctx)
	case wx.FieldProcessID:
		return m.OldProcessID(ctx)
	case wx.FieldCallback:
		return m.OldCallback(ctx)
	case wx.FieldWxid:
		return m.OldWxid(ctx)
	case wx.FieldAccount:
		return m.OldAccount(ctx)
	case wx.FieldNickname:
		return m.OldNickname(ctx)
	case wx.FieldTel:
		return m.OldTel(ctx)
	case wx.FieldHeadBig:
		return m.OldHeadBig(ctx)
	}
	return nil, fmt.Errorf("unknown Wx 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 *WxMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wx.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 wx.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case wx.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case wx.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case wx.FieldServerID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetServerID(v)
		return nil
	case wx.FieldPort:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPort(v)
		return nil
	case wx.FieldProcessID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetProcessID(v)
		return nil
	case wx.FieldCallback:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCallback(v)
		return nil
	case wx.FieldWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxid(v)
		return nil
	case wx.FieldAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccount(v)
		return nil
	case wx.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case wx.FieldTel:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTel(v)
		return nil
	case wx.FieldHeadBig:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHeadBig(v)
		return nil
	}
	return fmt.Errorf("unknown Wx field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WxMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, wx.FieldStatus)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *WxMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case wx.FieldStatus:
		return m.AddedStatus()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *WxMutation) AddField(name string, value ent.Value) error {
	switch name {
	case wx.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	}
	return fmt.Errorf("unknown Wx numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WxMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(wx.FieldStatus) {
		fields = append(fields, wx.FieldStatus)
	}
	if m.FieldCleared(wx.FieldDeletedAt) {
		fields = append(fields, wx.FieldDeletedAt)
	}
	if m.FieldCleared(wx.FieldServerID) {
		fields = append(fields, wx.FieldServerID)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WxMutation) 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 *WxMutation) ClearField(name string) error {
	switch name {
	case wx.FieldStatus:
		m.ClearStatus()
		return nil
	case wx.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case wx.FieldServerID:
		m.ClearServerID()
		return nil
	}
	return fmt.Errorf("unknown Wx 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 *WxMutation) ResetField(name string) error {
	switch name {
	case wx.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wx.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wx.FieldStatus:
		m.ResetStatus()
		return nil
	case wx.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case wx.FieldServerID:
		m.ResetServerID()
		return nil
	case wx.FieldPort:
		m.ResetPort()
		return nil
	case wx.FieldProcessID:
		m.ResetProcessID()
		return nil
	case wx.FieldCallback:
		m.ResetCallback()
		return nil
	case wx.FieldWxid:
		m.ResetWxid()
		return nil
	case wx.FieldAccount:
		m.ResetAccount()
		return nil
	case wx.FieldNickname:
		m.ResetNickname()
		return nil
	case wx.FieldTel:
		m.ResetTel()
		return nil
	case wx.FieldHeadBig:
		m.ResetHeadBig()
		return nil
	}
	return fmt.Errorf("unknown Wx field %s", name)
}

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WxMutation) EdgeCleared(name string) bool {
	switch name {
	case wx.EdgeServer:
		return m.clearedserver
	}
	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 *WxMutation) ClearEdge(name string) error {
	switch name {
	case wx.EdgeServer:
		m.ClearServer()
		return nil
	}
	return fmt.Errorf("unknown Wx 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 *WxMutation) ResetEdge(name string) error {
	switch name {
	case wx.EdgeServer:
		m.ResetServer()
		return nil
	}
	return fmt.Errorf("unknown Wx edge %s", name)
}