wechat-api/ent/mutation.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"
	"wechat-api/ent/agent"
	"wechat-api/ent/agentbase"
	"wechat-api/ent/batchmsg"
	"wechat-api/ent/category"
	"wechat-api/ent/chatrecords"
	"wechat-api/ent/chatsession"
	"wechat-api/ent/contact"
	"wechat-api/ent/custom_types"
	"wechat-api/ent/employee"
	"wechat-api/ent/employeeconfig"
	"wechat-api/ent/label"
	"wechat-api/ent/labelrelationship"
	"wechat-api/ent/message"
	"wechat-api/ent/messagerecords"
	"wechat-api/ent/msg"
	"wechat-api/ent/predicate"
	"wechat-api/ent/server"
	"wechat-api/ent/sopnode"
	"wechat-api/ent/sopstage"
	"wechat-api/ent/soptask"
	"wechat-api/ent/token"
	"wechat-api/ent/tutorial"
	"wechat-api/ent/workexperience"
	"wechat-api/ent/wx"
	"wechat-api/ent/wxcard"
	"wechat-api/ent/wxcarduser"
	"wechat-api/ent/wxcardvisit"

	"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.
	TypeAgent             = "Agent"
	TypeAgentBase         = "AgentBase"
	TypeBatchMsg          = "BatchMsg"
	TypeCategory          = "Category"
	TypeChatRecords       = "ChatRecords"
	TypeChatSession       = "ChatSession"
	TypeContact           = "Contact"
	TypeEmployee          = "Employee"
	TypeEmployeeConfig    = "EmployeeConfig"
	TypeLabel             = "Label"
	TypeLabelRelationship = "LabelRelationship"
	TypeMessage           = "Message"
	TypeMessageRecords    = "MessageRecords"
	TypeMsg               = "Msg"
	TypeServer            = "Server"
	TypeSopNode           = "SopNode"
	TypeSopStage          = "SopStage"
	TypeSopTask           = "SopTask"
	TypeToken             = "Token"
	TypeTutorial          = "Tutorial"
	TypeWorkExperience    = "WorkExperience"
	TypeWx                = "Wx"
	TypeWxCard            = "WxCard"
	TypeWxCardUser        = "WxCardUser"
	TypeWxCardVisit       = "WxCardVisit"
)

// AgentMutation represents an operation that mutates the Agent nodes in the graph.
type AgentMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	name               *string
	role               *string
	status             *int
	addstatus          *int
	background         *string
	examples           *string
	organization_id    *uint64
	addorganization_id *int64
	dataset_id         *string
	collection_id      *string
	clearedFields      map[string]struct{}
	wx_agent           map[uint64]struct{}
	removedwx_agent    map[uint64]struct{}
	clearedwx_agent    bool
	done               bool
	oldValue           func(context.Context) (*Agent, error)
	predicates         []predicate.Agent
}

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

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

// newAgentMutation creates new mutation for the Agent entity.
func newAgentMutation(c config, op Op, opts ...agentOption) *AgentMutation {
	m := &AgentMutation{
		config:        c,
		op:            op,
		typ:           TypeAgent,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withAgent sets the old Agent of the mutation.
func withAgent(node *Agent) agentOption {
	return func(m *AgentMutation) {
		m.oldValue = func(context.Context) (*Agent, 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 AgentMutation) 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 AgentMutation) 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 Agent entities.
func (m *AgentMutation) 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 *AgentMutation) 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 *AgentMutation) 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().Agent.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 *AgentMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *AgentMutation) 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 Agent entity.
// If the Agent 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 *AgentMutation) 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 *AgentMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[agent.FieldDeletedAt] = struct{}{}
}

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

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

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

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

// SetRole sets the "role" field.
func (m *AgentMutation) SetRole(s string) {
	m.role = &s
}

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

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

// ResetRole resets all changes to the "role" field.
func (m *AgentMutation) ResetRole() {
	m.role = nil
}

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

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

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

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

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

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

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

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

// SetBackground sets the "background" field.
func (m *AgentMutation) SetBackground(s string) {
	m.background = &s
}

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

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

// ClearBackground clears the value of the "background" field.
func (m *AgentMutation) ClearBackground() {
	m.background = nil
	m.clearedFields[agent.FieldBackground] = struct{}{}
}

// BackgroundCleared returns if the "background" field was cleared in this mutation.
func (m *AgentMutation) BackgroundCleared() bool {
	_, ok := m.clearedFields[agent.FieldBackground]
	return ok
}

// ResetBackground resets all changes to the "background" field.
func (m *AgentMutation) ResetBackground() {
	m.background = nil
	delete(m.clearedFields, agent.FieldBackground)
}

// SetExamples sets the "examples" field.
func (m *AgentMutation) SetExamples(s string) {
	m.examples = &s
}

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

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

// ClearExamples clears the value of the "examples" field.
func (m *AgentMutation) ClearExamples() {
	m.examples = nil
	m.clearedFields[agent.FieldExamples] = struct{}{}
}

// ExamplesCleared returns if the "examples" field was cleared in this mutation.
func (m *AgentMutation) ExamplesCleared() bool {
	_, ok := m.clearedFields[agent.FieldExamples]
	return ok
}

// ResetExamples resets all changes to the "examples" field.
func (m *AgentMutation) ResetExamples() {
	m.examples = nil
	delete(m.clearedFields, agent.FieldExamples)
}

// SetOrganizationID sets the "organization_id" field.
func (m *AgentMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

// SetDatasetID sets the "dataset_id" field.
func (m *AgentMutation) SetDatasetID(s string) {
	m.dataset_id = &s
}

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

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

// ResetDatasetID resets all changes to the "dataset_id" field.
func (m *AgentMutation) ResetDatasetID() {
	m.dataset_id = nil
}

// SetCollectionID sets the "collection_id" field.
func (m *AgentMutation) SetCollectionID(s string) {
	m.collection_id = &s
}

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

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

// ResetCollectionID resets all changes to the "collection_id" field.
func (m *AgentMutation) ResetCollectionID() {
	m.collection_id = nil
}

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

// ClearWxAgent clears the "wx_agent" edge to the Wx entity.
func (m *AgentMutation) ClearWxAgent() {
	m.clearedwx_agent = true
}

// WxAgentCleared reports if the "wx_agent" edge to the Wx entity was cleared.
func (m *AgentMutation) WxAgentCleared() bool {
	return m.clearedwx_agent
}

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

// RemovedWxAgent returns the removed IDs of the "wx_agent" edge to the Wx entity.
func (m *AgentMutation) RemovedWxAgentIDs() (ids []uint64) {
	for id := range m.removedwx_agent {
		ids = append(ids, id)
	}
	return
}

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

// ResetWxAgent resets all changes to the "wx_agent" edge.
func (m *AgentMutation) ResetWxAgent() {
	m.wx_agent = nil
	m.clearedwx_agent = false
	m.removedwx_agent = nil
}

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

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

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

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

// Type returns the node type of this mutation (Agent).
func (m *AgentMutation) 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 *AgentMutation) Fields() []string {
	fields := make([]string, 0, 11)
	if m.created_at != nil {
		fields = append(fields, agent.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, agent.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, agent.FieldDeletedAt)
	}
	if m.name != nil {
		fields = append(fields, agent.FieldName)
	}
	if m.role != nil {
		fields = append(fields, agent.FieldRole)
	}
	if m.status != nil {
		fields = append(fields, agent.FieldStatus)
	}
	if m.background != nil {
		fields = append(fields, agent.FieldBackground)
	}
	if m.examples != nil {
		fields = append(fields, agent.FieldExamples)
	}
	if m.organization_id != nil {
		fields = append(fields, agent.FieldOrganizationID)
	}
	if m.dataset_id != nil {
		fields = append(fields, agent.FieldDatasetID)
	}
	if m.collection_id != nil {
		fields = append(fields, agent.FieldCollectionID)
	}
	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 *AgentMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case agent.FieldCreatedAt:
		return m.CreatedAt()
	case agent.FieldUpdatedAt:
		return m.UpdatedAt()
	case agent.FieldDeletedAt:
		return m.DeletedAt()
	case agent.FieldName:
		return m.Name()
	case agent.FieldRole:
		return m.Role()
	case agent.FieldStatus:
		return m.Status()
	case agent.FieldBackground:
		return m.Background()
	case agent.FieldExamples:
		return m.Examples()
	case agent.FieldOrganizationID:
		return m.OrganizationID()
	case agent.FieldDatasetID:
		return m.DatasetID()
	case agent.FieldCollectionID:
		return m.CollectionID()
	}
	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 *AgentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case agent.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case agent.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case agent.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case agent.FieldName:
		return m.OldName(ctx)
	case agent.FieldRole:
		return m.OldRole(ctx)
	case agent.FieldStatus:
		return m.OldStatus(ctx)
	case agent.FieldBackground:
		return m.OldBackground(ctx)
	case agent.FieldExamples:
		return m.OldExamples(ctx)
	case agent.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case agent.FieldDatasetID:
		return m.OldDatasetID(ctx)
	case agent.FieldCollectionID:
		return m.OldCollectionID(ctx)
	}
	return nil, fmt.Errorf("unknown Agent 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 *AgentMutation) SetField(name string, value ent.Value) error {
	switch name {
	case agent.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 agent.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 agent.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 agent.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case agent.FieldRole:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRole(v)
		return nil
	case agent.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case agent.FieldBackground:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBackground(v)
		return nil
	case agent.FieldExamples:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExamples(v)
		return nil
	case agent.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case agent.FieldDatasetID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDatasetID(v)
		return nil
	case agent.FieldCollectionID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCollectionID(v)
		return nil
	}
	return fmt.Errorf("unknown Agent field %s", name)
}

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

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

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *AgentMutation) 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 *AgentMutation) ClearField(name string) error {
	switch name {
	case agent.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case agent.FieldStatus:
		m.ClearStatus()
		return nil
	case agent.FieldBackground:
		m.ClearBackground()
		return nil
	case agent.FieldExamples:
		m.ClearExamples()
		return nil
	}
	return fmt.Errorf("unknown Agent 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 *AgentMutation) ResetField(name string) error {
	switch name {
	case agent.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case agent.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case agent.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case agent.FieldName:
		m.ResetName()
		return nil
	case agent.FieldRole:
		m.ResetRole()
		return nil
	case agent.FieldStatus:
		m.ResetStatus()
		return nil
	case agent.FieldBackground:
		m.ResetBackground()
		return nil
	case agent.FieldExamples:
		m.ResetExamples()
		return nil
	case agent.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case agent.FieldDatasetID:
		m.ResetDatasetID()
		return nil
	case agent.FieldCollectionID:
		m.ResetCollectionID()
		return nil
	}
	return fmt.Errorf("unknown Agent field %s", name)
}

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

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

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

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

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

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

// AgentBaseMutation represents an operation that mutates the AgentBase nodes in the graph.
type AgentBaseMutation struct {
	config
	op              Op
	typ             string
	id              *string
	q               *string
	a               *string
	chunk_index     *uint64
	addchunk_index  *int64
	indexes         *[]string
	appendindexes   []string
	dataset_id      *string
	collection_id   *string
	source_name     *string
	can_write       *[]bool
	appendcan_write []bool
	is_owner        *[]bool
	appendis_owner  []bool
	clearedFields   map[string]struct{}
	wx_agent        map[uint64]struct{}
	removedwx_agent map[uint64]struct{}
	clearedwx_agent bool
	done            bool
	oldValue        func(context.Context) (*AgentBase, error)
	predicates      []predicate.AgentBase
}

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

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

// newAgentBaseMutation creates new mutation for the AgentBase entity.
func newAgentBaseMutation(c config, op Op, opts ...agentbaseOption) *AgentBaseMutation {
	m := &AgentBaseMutation{
		config:        c,
		op:            op,
		typ:           TypeAgentBase,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// SetQ sets the "q" field.
func (m *AgentBaseMutation) SetQ(s string) {
	m.q = &s
}

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

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

// ClearQ clears the value of the "q" field.
func (m *AgentBaseMutation) ClearQ() {
	m.q = nil
	m.clearedFields[agentbase.FieldQ] = struct{}{}
}

// QCleared returns if the "q" field was cleared in this mutation.
func (m *AgentBaseMutation) QCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldQ]
	return ok
}

// ResetQ resets all changes to the "q" field.
func (m *AgentBaseMutation) ResetQ() {
	m.q = nil
	delete(m.clearedFields, agentbase.FieldQ)
}

// SetA sets the "a" field.
func (m *AgentBaseMutation) SetA(s string) {
	m.a = &s
}

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

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

// ClearA clears the value of the "a" field.
func (m *AgentBaseMutation) ClearA() {
	m.a = nil
	m.clearedFields[agentbase.FieldA] = struct{}{}
}

// ACleared returns if the "a" field was cleared in this mutation.
func (m *AgentBaseMutation) ACleared() bool {
	_, ok := m.clearedFields[agentbase.FieldA]
	return ok
}

// ResetA resets all changes to the "a" field.
func (m *AgentBaseMutation) ResetA() {
	m.a = nil
	delete(m.clearedFields, agentbase.FieldA)
}

// SetChunkIndex sets the "chunk_index" field.
func (m *AgentBaseMutation) SetChunkIndex(u uint64) {
	m.chunk_index = &u
	m.addchunk_index = nil
}

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

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

// AddChunkIndex adds u to the "chunk_index" field.
func (m *AgentBaseMutation) AddChunkIndex(u int64) {
	if m.addchunk_index != nil {
		*m.addchunk_index += u
	} else {
		m.addchunk_index = &u
	}
}

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

// ResetChunkIndex resets all changes to the "chunk_index" field.
func (m *AgentBaseMutation) ResetChunkIndex() {
	m.chunk_index = nil
	m.addchunk_index = nil
}

// SetIndexes sets the "indexes" field.
func (m *AgentBaseMutation) SetIndexes(s []string) {
	m.indexes = &s
	m.appendindexes = nil
}

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

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

// AppendIndexes adds s to the "indexes" field.
func (m *AgentBaseMutation) AppendIndexes(s []string) {
	m.appendindexes = append(m.appendindexes, s...)
}

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

// ClearIndexes clears the value of the "indexes" field.
func (m *AgentBaseMutation) ClearIndexes() {
	m.indexes = nil
	m.appendindexes = nil
	m.clearedFields[agentbase.FieldIndexes] = struct{}{}
}

// IndexesCleared returns if the "indexes" field was cleared in this mutation.
func (m *AgentBaseMutation) IndexesCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldIndexes]
	return ok
}

// ResetIndexes resets all changes to the "indexes" field.
func (m *AgentBaseMutation) ResetIndexes() {
	m.indexes = nil
	m.appendindexes = nil
	delete(m.clearedFields, agentbase.FieldIndexes)
}

// SetDatasetID sets the "dataset_id" field.
func (m *AgentBaseMutation) SetDatasetID(s string) {
	m.dataset_id = &s
}

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

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

// ClearDatasetID clears the value of the "dataset_id" field.
func (m *AgentBaseMutation) ClearDatasetID() {
	m.dataset_id = nil
	m.clearedFields[agentbase.FieldDatasetID] = struct{}{}
}

// DatasetIDCleared returns if the "dataset_id" field was cleared in this mutation.
func (m *AgentBaseMutation) DatasetIDCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldDatasetID]
	return ok
}

// ResetDatasetID resets all changes to the "dataset_id" field.
func (m *AgentBaseMutation) ResetDatasetID() {
	m.dataset_id = nil
	delete(m.clearedFields, agentbase.FieldDatasetID)
}

// SetCollectionID sets the "collection_id" field.
func (m *AgentBaseMutation) SetCollectionID(s string) {
	m.collection_id = &s
}

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

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

// ClearCollectionID clears the value of the "collection_id" field.
func (m *AgentBaseMutation) ClearCollectionID() {
	m.collection_id = nil
	m.clearedFields[agentbase.FieldCollectionID] = struct{}{}
}

// CollectionIDCleared returns if the "collection_id" field was cleared in this mutation.
func (m *AgentBaseMutation) CollectionIDCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldCollectionID]
	return ok
}

// ResetCollectionID resets all changes to the "collection_id" field.
func (m *AgentBaseMutation) ResetCollectionID() {
	m.collection_id = nil
	delete(m.clearedFields, agentbase.FieldCollectionID)
}

// SetSourceName sets the "source_name" field.
func (m *AgentBaseMutation) SetSourceName(s string) {
	m.source_name = &s
}

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

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

// ClearSourceName clears the value of the "source_name" field.
func (m *AgentBaseMutation) ClearSourceName() {
	m.source_name = nil
	m.clearedFields[agentbase.FieldSourceName] = struct{}{}
}

// SourceNameCleared returns if the "source_name" field was cleared in this mutation.
func (m *AgentBaseMutation) SourceNameCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldSourceName]
	return ok
}

// ResetSourceName resets all changes to the "source_name" field.
func (m *AgentBaseMutation) ResetSourceName() {
	m.source_name = nil
	delete(m.clearedFields, agentbase.FieldSourceName)
}

// SetCanWrite sets the "can_write" field.
func (m *AgentBaseMutation) SetCanWrite(b []bool) {
	m.can_write = &b
	m.appendcan_write = nil
}

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

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

// AppendCanWrite adds b to the "can_write" field.
func (m *AgentBaseMutation) AppendCanWrite(b []bool) {
	m.appendcan_write = append(m.appendcan_write, b...)
}

// AppendedCanWrite returns the list of values that were appended to the "can_write" field in this mutation.
func (m *AgentBaseMutation) AppendedCanWrite() ([]bool, bool) {
	if len(m.appendcan_write) == 0 {
		return nil, false
	}
	return m.appendcan_write, true
}

// ClearCanWrite clears the value of the "can_write" field.
func (m *AgentBaseMutation) ClearCanWrite() {
	m.can_write = nil
	m.appendcan_write = nil
	m.clearedFields[agentbase.FieldCanWrite] = struct{}{}
}

// CanWriteCleared returns if the "can_write" field was cleared in this mutation.
func (m *AgentBaseMutation) CanWriteCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldCanWrite]
	return ok
}

// ResetCanWrite resets all changes to the "can_write" field.
func (m *AgentBaseMutation) ResetCanWrite() {
	m.can_write = nil
	m.appendcan_write = nil
	delete(m.clearedFields, agentbase.FieldCanWrite)
}

// SetIsOwner sets the "is_owner" field.
func (m *AgentBaseMutation) SetIsOwner(b []bool) {
	m.is_owner = &b
	m.appendis_owner = nil
}

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

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

// AppendIsOwner adds b to the "is_owner" field.
func (m *AgentBaseMutation) AppendIsOwner(b []bool) {
	m.appendis_owner = append(m.appendis_owner, b...)
}

// AppendedIsOwner returns the list of values that were appended to the "is_owner" field in this mutation.
func (m *AgentBaseMutation) AppendedIsOwner() ([]bool, bool) {
	if len(m.appendis_owner) == 0 {
		return nil, false
	}
	return m.appendis_owner, true
}

// ClearIsOwner clears the value of the "is_owner" field.
func (m *AgentBaseMutation) ClearIsOwner() {
	m.is_owner = nil
	m.appendis_owner = nil
	m.clearedFields[agentbase.FieldIsOwner] = struct{}{}
}

// IsOwnerCleared returns if the "is_owner" field was cleared in this mutation.
func (m *AgentBaseMutation) IsOwnerCleared() bool {
	_, ok := m.clearedFields[agentbase.FieldIsOwner]
	return ok
}

// ResetIsOwner resets all changes to the "is_owner" field.
func (m *AgentBaseMutation) ResetIsOwner() {
	m.is_owner = nil
	m.appendis_owner = nil
	delete(m.clearedFields, agentbase.FieldIsOwner)
}

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

// ClearWxAgent clears the "wx_agent" edge to the Wx entity.
func (m *AgentBaseMutation) ClearWxAgent() {
	m.clearedwx_agent = true
}

// WxAgentCleared reports if the "wx_agent" edge to the Wx entity was cleared.
func (m *AgentBaseMutation) WxAgentCleared() bool {
	return m.clearedwx_agent
}

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

// RemovedWxAgent returns the removed IDs of the "wx_agent" edge to the Wx entity.
func (m *AgentBaseMutation) RemovedWxAgentIDs() (ids []uint64) {
	for id := range m.removedwx_agent {
		ids = append(ids, id)
	}
	return
}

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

// ResetWxAgent resets all changes to the "wx_agent" edge.
func (m *AgentBaseMutation) ResetWxAgent() {
	m.wx_agent = nil
	m.clearedwx_agent = false
	m.removedwx_agent = nil
}

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

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

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

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

// Type returns the node type of this mutation (AgentBase).
func (m *AgentBaseMutation) 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 *AgentBaseMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.q != nil {
		fields = append(fields, agentbase.FieldQ)
	}
	if m.a != nil {
		fields = append(fields, agentbase.FieldA)
	}
	if m.chunk_index != nil {
		fields = append(fields, agentbase.FieldChunkIndex)
	}
	if m.indexes != nil {
		fields = append(fields, agentbase.FieldIndexes)
	}
	if m.dataset_id != nil {
		fields = append(fields, agentbase.FieldDatasetID)
	}
	if m.collection_id != nil {
		fields = append(fields, agentbase.FieldCollectionID)
	}
	if m.source_name != nil {
		fields = append(fields, agentbase.FieldSourceName)
	}
	if m.can_write != nil {
		fields = append(fields, agentbase.FieldCanWrite)
	}
	if m.is_owner != nil {
		fields = append(fields, agentbase.FieldIsOwner)
	}
	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 *AgentBaseMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case agentbase.FieldQ:
		return m.Q()
	case agentbase.FieldA:
		return m.A()
	case agentbase.FieldChunkIndex:
		return m.ChunkIndex()
	case agentbase.FieldIndexes:
		return m.Indexes()
	case agentbase.FieldDatasetID:
		return m.DatasetID()
	case agentbase.FieldCollectionID:
		return m.CollectionID()
	case agentbase.FieldSourceName:
		return m.SourceName()
	case agentbase.FieldCanWrite:
		return m.CanWrite()
	case agentbase.FieldIsOwner:
		return m.IsOwner()
	}
	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 *AgentBaseMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case agentbase.FieldQ:
		return m.OldQ(ctx)
	case agentbase.FieldA:
		return m.OldA(ctx)
	case agentbase.FieldChunkIndex:
		return m.OldChunkIndex(ctx)
	case agentbase.FieldIndexes:
		return m.OldIndexes(ctx)
	case agentbase.FieldDatasetID:
		return m.OldDatasetID(ctx)
	case agentbase.FieldCollectionID:
		return m.OldCollectionID(ctx)
	case agentbase.FieldSourceName:
		return m.OldSourceName(ctx)
	case agentbase.FieldCanWrite:
		return m.OldCanWrite(ctx)
	case agentbase.FieldIsOwner:
		return m.OldIsOwner(ctx)
	}
	return nil, fmt.Errorf("unknown AgentBase 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 *AgentBaseMutation) SetField(name string, value ent.Value) error {
	switch name {
	case agentbase.FieldQ:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetQ(v)
		return nil
	case agentbase.FieldA:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetA(v)
		return nil
	case agentbase.FieldChunkIndex:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChunkIndex(v)
		return nil
	case agentbase.FieldIndexes:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIndexes(v)
		return nil
	case agentbase.FieldDatasetID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDatasetID(v)
		return nil
	case agentbase.FieldCollectionID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCollectionID(v)
		return nil
	case agentbase.FieldSourceName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSourceName(v)
		return nil
	case agentbase.FieldCanWrite:
		v, ok := value.([]bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCanWrite(v)
		return nil
	case agentbase.FieldIsOwner:
		v, ok := value.([]bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsOwner(v)
		return nil
	}
	return fmt.Errorf("unknown AgentBase field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *AgentBaseMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(agentbase.FieldQ) {
		fields = append(fields, agentbase.FieldQ)
	}
	if m.FieldCleared(agentbase.FieldA) {
		fields = append(fields, agentbase.FieldA)
	}
	if m.FieldCleared(agentbase.FieldIndexes) {
		fields = append(fields, agentbase.FieldIndexes)
	}
	if m.FieldCleared(agentbase.FieldDatasetID) {
		fields = append(fields, agentbase.FieldDatasetID)
	}
	if m.FieldCleared(agentbase.FieldCollectionID) {
		fields = append(fields, agentbase.FieldCollectionID)
	}
	if m.FieldCleared(agentbase.FieldSourceName) {
		fields = append(fields, agentbase.FieldSourceName)
	}
	if m.FieldCleared(agentbase.FieldCanWrite) {
		fields = append(fields, agentbase.FieldCanWrite)
	}
	if m.FieldCleared(agentbase.FieldIsOwner) {
		fields = append(fields, agentbase.FieldIsOwner)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *AgentBaseMutation) 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 *AgentBaseMutation) ClearField(name string) error {
	switch name {
	case agentbase.FieldQ:
		m.ClearQ()
		return nil
	case agentbase.FieldA:
		m.ClearA()
		return nil
	case agentbase.FieldIndexes:
		m.ClearIndexes()
		return nil
	case agentbase.FieldDatasetID:
		m.ClearDatasetID()
		return nil
	case agentbase.FieldCollectionID:
		m.ClearCollectionID()
		return nil
	case agentbase.FieldSourceName:
		m.ClearSourceName()
		return nil
	case agentbase.FieldCanWrite:
		m.ClearCanWrite()
		return nil
	case agentbase.FieldIsOwner:
		m.ClearIsOwner()
		return nil
	}
	return fmt.Errorf("unknown AgentBase 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 *AgentBaseMutation) ResetField(name string) error {
	switch name {
	case agentbase.FieldQ:
		m.ResetQ()
		return nil
	case agentbase.FieldA:
		m.ResetA()
		return nil
	case agentbase.FieldChunkIndex:
		m.ResetChunkIndex()
		return nil
	case agentbase.FieldIndexes:
		m.ResetIndexes()
		return nil
	case agentbase.FieldDatasetID:
		m.ResetDatasetID()
		return nil
	case agentbase.FieldCollectionID:
		m.ResetCollectionID()
		return nil
	case agentbase.FieldSourceName:
		m.ResetSourceName()
		return nil
	case agentbase.FieldCanWrite:
		m.ResetCanWrite()
		return nil
	case agentbase.FieldIsOwner:
		m.ResetIsOwner()
		return nil
	}
	return fmt.Errorf("unknown AgentBase field %s", name)
}

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

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

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

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

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

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

// 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
	task_name          *string
	fromwxid           *string
	msg                *string
	tag                *string
	tagids             *string
	total              *int32
	addtotal           *int32
	success            *int32
	addsuccess         *int32
	fail               *int32
	addfail            *int32
	start_time         *time.Time
	stop_time          *time.Time
	send_time          *time.Time
	_type              *int32
	add_type           *int32
	organization_id    *uint64
	addorganization_id *int64
	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)
}

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

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

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

// ClearTaskName clears the value of the "task_name" field.
func (m *BatchMsgMutation) ClearTaskName() {
	m.task_name = nil
	m.clearedFields[batchmsg.FieldTaskName] = struct{}{}
}

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

// ResetTaskName resets all changes to the "task_name" field.
func (m *BatchMsgMutation) ResetTaskName() {
	m.task_name = nil
	delete(m.clearedFields, batchmsg.FieldTaskName)
}

// 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)
}

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

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

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

// ClearTagids clears the value of the "tagids" field.
func (m *BatchMsgMutation) ClearTagids() {
	m.tagids = nil
	m.clearedFields[batchmsg.FieldTagids] = struct{}{}
}

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

// ResetTagids resets all changes to the "tagids" field.
func (m *BatchMsgMutation) ResetTagids() {
	m.tagids = nil
	delete(m.clearedFields, batchmsg.FieldTagids)
}

// 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)
}

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

// SendTime returns the value of the "send_time" field in the mutation.
func (m *BatchMsgMutation) 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 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) 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 *BatchMsgMutation) ClearSendTime() {
	m.send_time = nil
	m.clearedFields[batchmsg.FieldSendTime] = struct{}{}
}

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

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

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

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

// OldType returns the old "type" 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) OldType(ctx context.Context) (v int32, 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 *BatchMsgMutation) AddType(i int32) {
	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 *BatchMsgMutation) AddedType() (r int32, exists bool) {
	v := m.add_type
	if v == nil {
		return
	}
	return *v, true
}

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

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *BatchMsgMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

// 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, 18)
	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.task_name != nil {
		fields = append(fields, batchmsg.FieldTaskName)
	}
	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.tagids != nil {
		fields = append(fields, batchmsg.FieldTagids)
	}
	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)
	}
	if m.send_time != nil {
		fields = append(fields, batchmsg.FieldSendTime)
	}
	if m._type != nil {
		fields = append(fields, batchmsg.FieldType)
	}
	if m.organization_id != nil {
		fields = append(fields, batchmsg.FieldOrganizationID)
	}
	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.FieldTaskName:
		return m.TaskName()
	case batchmsg.FieldFromwxid:
		return m.Fromwxid()
	case batchmsg.FieldMsg:
		return m.Msg()
	case batchmsg.FieldTag:
		return m.Tag()
	case batchmsg.FieldTagids:
		return m.Tagids()
	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()
	case batchmsg.FieldSendTime:
		return m.SendTime()
	case batchmsg.FieldType:
		return m.GetType()
	case batchmsg.FieldOrganizationID:
		return m.OrganizationID()
	}
	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.FieldTaskName:
		return m.OldTaskName(ctx)
	case batchmsg.FieldFromwxid:
		return m.OldFromwxid(ctx)
	case batchmsg.FieldMsg:
		return m.OldMsg(ctx)
	case batchmsg.FieldTag:
		return m.OldTag(ctx)
	case batchmsg.FieldTagids:
		return m.OldTagids(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)
	case batchmsg.FieldSendTime:
		return m.OldSendTime(ctx)
	case batchmsg.FieldType:
		return m.OldType(ctx)
	case batchmsg.FieldOrganizationID:
		return m.OldOrganizationID(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.FieldTaskName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTaskName(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.FieldTagids:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTagids(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
	case batchmsg.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 batchmsg.FieldType:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case batchmsg.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.add_type != nil {
		fields = append(fields, batchmsg.FieldType)
	}
	if m.addorganization_id != nil {
		fields = append(fields, batchmsg.FieldOrganizationID)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *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()
	case batchmsg.FieldType:
		return m.AddedType()
	case batchmsg.FieldOrganizationID:
		return m.AddedOrganizationID()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case batchmsg.FieldType:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case batchmsg.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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.FieldTaskName) {
		fields = append(fields, batchmsg.FieldTaskName)
	}
	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.FieldTagids) {
		fields = append(fields, batchmsg.FieldTagids)
	}
	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)
	}
	if m.FieldCleared(batchmsg.FieldSendTime) {
		fields = append(fields, batchmsg.FieldSendTime)
	}
	if m.FieldCleared(batchmsg.FieldType) {
		fields = append(fields, batchmsg.FieldType)
	}
	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.FieldTaskName:
		m.ClearTaskName()
		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.FieldTagids:
		m.ClearTagids()
		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
	case batchmsg.FieldSendTime:
		m.ClearSendTime()
		return nil
	case batchmsg.FieldType:
		m.ClearType()
		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.FieldTaskName:
		m.ResetTaskName()
		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.FieldTagids:
		m.ResetTagids()
		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
	case batchmsg.FieldSendTime:
		m.ResetSendTime()
		return nil
	case batchmsg.FieldType:
		m.ResetType()
		return nil
	case batchmsg.FieldOrganizationID:
		m.ResetOrganizationID()
		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)
}

// CategoryMutation represents an operation that mutates the Category nodes in the graph.
type CategoryMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	name               *string
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*Category, error)
	predicates         []predicate.Category
}

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

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

// newCategoryMutation creates new mutation for the Category entity.
func newCategoryMutation(c config, op Op, opts ...categoryOption) *CategoryMutation {
	m := &CategoryMutation{
		config:        c,
		op:            op,
		typ:           TypeCategory,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCategory sets the old Category of the mutation.
func withCategory(node *Category) categoryOption {
	return func(m *CategoryMutation) {
		m.oldValue = func(context.Context) (*Category, 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 CategoryMutation) 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 CategoryMutation) 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 Category entities.
func (m *CategoryMutation) 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 *CategoryMutation) 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 *CategoryMutation) 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().Category.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 *CategoryMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *CategoryMutation) 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 Category entity.
// If the Category 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 *CategoryMutation) 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 *CategoryMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[category.FieldDeletedAt] = struct{}{}
}

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

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

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *CategoryMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

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

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

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

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

// Type returns the node type of this mutation (Category).
func (m *CategoryMutation) 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 *CategoryMutation) Fields() []string {
	fields := make([]string, 0, 5)
	if m.created_at != nil {
		fields = append(fields, category.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, category.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, category.FieldDeletedAt)
	}
	if m.name != nil {
		fields = append(fields, category.FieldName)
	}
	if m.organization_id != nil {
		fields = append(fields, category.FieldOrganizationID)
	}
	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 *CategoryMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case category.FieldCreatedAt:
		return m.CreatedAt()
	case category.FieldUpdatedAt:
		return m.UpdatedAt()
	case category.FieldDeletedAt:
		return m.DeletedAt()
	case category.FieldName:
		return m.Name()
	case category.FieldOrganizationID:
		return m.OrganizationID()
	}
	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 *CategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case category.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case category.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case category.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case category.FieldName:
		return m.OldName(ctx)
	case category.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown Category 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 *CategoryMutation) SetField(name string, value ent.Value) error {
	switch name {
	case category.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 category.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 category.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 category.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case category.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown Category field %s", name)
}

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

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

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CategoryMutation) 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 *CategoryMutation) ClearField(name string) error {
	switch name {
	case category.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Category 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 *CategoryMutation) ResetField(name string) error {
	switch name {
	case category.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case category.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case category.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case category.FieldName:
		m.ResetName()
		return nil
	case category.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown Category field %s", name)
}

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

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

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

// ChatRecordsMutation represents an operation that mutates the ChatRecords nodes in the graph.
type ChatRecordsMutation struct {
	config
	op              Op
	typ             string
	id              *uint64
	created_at      *time.Time
	updated_at      *time.Time
	deleted_at      *time.Time
	content         *string
	content_type    *uint8
	addcontent_type *int8
	session_id      *uint64
	addsession_id   *int64
	user_id         *uint64
	adduser_id      *int64
	bot_id          *uint64
	addbot_id       *int64
	bot_type        *uint8
	addbot_type     *int8
	clearedFields   map[string]struct{}
	done            bool
	oldValue        func(context.Context) (*ChatRecords, error)
	predicates      []predicate.ChatRecords
}

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

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

// newChatRecordsMutation creates new mutation for the ChatRecords entity.
func newChatRecordsMutation(c config, op Op, opts ...chatrecordsOption) *ChatRecordsMutation {
	m := &ChatRecordsMutation{
		config:        c,
		op:            op,
		typ:           TypeChatRecords,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withChatRecords sets the old ChatRecords of the mutation.
func withChatRecords(node *ChatRecords) chatrecordsOption {
	return func(m *ChatRecordsMutation) {
		m.oldValue = func(context.Context) (*ChatRecords, 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 ChatRecordsMutation) 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 ChatRecordsMutation) 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 ChatRecords entities.
func (m *ChatRecordsMutation) 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 *ChatRecordsMutation) 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 *ChatRecordsMutation) 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().ChatRecords.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 *ChatRecordsMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *ChatRecordsMutation) 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 ChatRecords entity.
// If the ChatRecords 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 *ChatRecordsMutation) 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 *ChatRecordsMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[chatrecords.FieldDeletedAt] = struct{}{}
}

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

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

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

// Content returns the value of the "content" field in the mutation.
func (m *ChatRecordsMutation) 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 ChatRecords entity.
// If the ChatRecords 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 *ChatRecordsMutation) 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 *ChatRecordsMutation) ResetContent() {
	m.content = nil
}

// SetContentType sets the "content_type" field.
func (m *ChatRecordsMutation) SetContentType(u uint8) {
	m.content_type = &u
	m.addcontent_type = nil
}

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

// OldContentType returns the old "content_type" field's value of the ChatRecords entity.
// If the ChatRecords 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 *ChatRecordsMutation) OldContentType(ctx context.Context) (v uint8, 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 u to the "content_type" field.
func (m *ChatRecordsMutation) AddContentType(u int8) {
	if m.addcontent_type != nil {
		*m.addcontent_type += u
	} else {
		m.addcontent_type = &u
	}
}

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

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

// SetSessionID sets the "session_id" field.
func (m *ChatRecordsMutation) SetSessionID(u uint64) {
	m.session_id = &u
	m.addsession_id = nil
}

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

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

// AddSessionID adds u to the "session_id" field.
func (m *ChatRecordsMutation) AddSessionID(u int64) {
	if m.addsession_id != nil {
		*m.addsession_id += u
	} else {
		m.addsession_id = &u
	}
}

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

// ResetSessionID resets all changes to the "session_id" field.
func (m *ChatRecordsMutation) ResetSessionID() {
	m.session_id = nil
	m.addsession_id = nil
}

// SetUserID sets the "user_id" field.
func (m *ChatRecordsMutation) SetUserID(u uint64) {
	m.user_id = &u
	m.adduser_id = nil
}

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

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

// AddUserID adds u to the "user_id" field.
func (m *ChatRecordsMutation) AddUserID(u int64) {
	if m.adduser_id != nil {
		*m.adduser_id += u
	} else {
		m.adduser_id = &u
	}
}

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

// ResetUserID resets all changes to the "user_id" field.
func (m *ChatRecordsMutation) ResetUserID() {
	m.user_id = nil
	m.adduser_id = nil
}

// SetBotID sets the "bot_id" field.
func (m *ChatRecordsMutation) SetBotID(u uint64) {
	m.bot_id = &u
	m.addbot_id = nil
}

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

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

// AddBotID adds u to the "bot_id" field.
func (m *ChatRecordsMutation) AddBotID(u int64) {
	if m.addbot_id != nil {
		*m.addbot_id += u
	} else {
		m.addbot_id = &u
	}
}

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

// ResetBotID resets all changes to the "bot_id" field.
func (m *ChatRecordsMutation) ResetBotID() {
	m.bot_id = nil
	m.addbot_id = nil
}

// SetBotType sets the "bot_type" field.
func (m *ChatRecordsMutation) SetBotType(u uint8) {
	m.bot_type = &u
	m.addbot_type = nil
}

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

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

// AddBotType adds u to the "bot_type" field.
func (m *ChatRecordsMutation) AddBotType(u int8) {
	if m.addbot_type != nil {
		*m.addbot_type += u
	} else {
		m.addbot_type = &u
	}
}

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

// ResetBotType resets all changes to the "bot_type" field.
func (m *ChatRecordsMutation) ResetBotType() {
	m.bot_type = nil
	m.addbot_type = nil
}

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

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

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

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

// Type returns the node type of this mutation (ChatRecords).
func (m *ChatRecordsMutation) 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 *ChatRecordsMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, chatrecords.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, chatrecords.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, chatrecords.FieldDeletedAt)
	}
	if m.content != nil {
		fields = append(fields, chatrecords.FieldContent)
	}
	if m.content_type != nil {
		fields = append(fields, chatrecords.FieldContentType)
	}
	if m.session_id != nil {
		fields = append(fields, chatrecords.FieldSessionID)
	}
	if m.user_id != nil {
		fields = append(fields, chatrecords.FieldUserID)
	}
	if m.bot_id != nil {
		fields = append(fields, chatrecords.FieldBotID)
	}
	if m.bot_type != nil {
		fields = append(fields, chatrecords.FieldBotType)
	}
	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 *ChatRecordsMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case chatrecords.FieldCreatedAt:
		return m.CreatedAt()
	case chatrecords.FieldUpdatedAt:
		return m.UpdatedAt()
	case chatrecords.FieldDeletedAt:
		return m.DeletedAt()
	case chatrecords.FieldContent:
		return m.Content()
	case chatrecords.FieldContentType:
		return m.ContentType()
	case chatrecords.FieldSessionID:
		return m.SessionID()
	case chatrecords.FieldUserID:
		return m.UserID()
	case chatrecords.FieldBotID:
		return m.BotID()
	case chatrecords.FieldBotType:
		return m.BotType()
	}
	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 *ChatRecordsMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case chatrecords.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case chatrecords.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case chatrecords.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case chatrecords.FieldContent:
		return m.OldContent(ctx)
	case chatrecords.FieldContentType:
		return m.OldContentType(ctx)
	case chatrecords.FieldSessionID:
		return m.OldSessionID(ctx)
	case chatrecords.FieldUserID:
		return m.OldUserID(ctx)
	case chatrecords.FieldBotID:
		return m.OldBotID(ctx)
	case chatrecords.FieldBotType:
		return m.OldBotType(ctx)
	}
	return nil, fmt.Errorf("unknown ChatRecords 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 *ChatRecordsMutation) SetField(name string, value ent.Value) error {
	switch name {
	case chatrecords.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 chatrecords.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 chatrecords.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 chatrecords.FieldContent:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContent(v)
		return nil
	case chatrecords.FieldContentType:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContentType(v)
		return nil
	case chatrecords.FieldSessionID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSessionID(v)
		return nil
	case chatrecords.FieldUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case chatrecords.FieldBotID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case chatrecords.FieldBotType:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotType(v)
		return nil
	}
	return fmt.Errorf("unknown ChatRecords field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ChatRecordsMutation) AddedFields() []string {
	var fields []string
	if m.addcontent_type != nil {
		fields = append(fields, chatrecords.FieldContentType)
	}
	if m.addsession_id != nil {
		fields = append(fields, chatrecords.FieldSessionID)
	}
	if m.adduser_id != nil {
		fields = append(fields, chatrecords.FieldUserID)
	}
	if m.addbot_id != nil {
		fields = append(fields, chatrecords.FieldBotID)
	}
	if m.addbot_type != nil {
		fields = append(fields, chatrecords.FieldBotType)
	}
	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 *ChatRecordsMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case chatrecords.FieldContentType:
		return m.AddedContentType()
	case chatrecords.FieldSessionID:
		return m.AddedSessionID()
	case chatrecords.FieldUserID:
		return m.AddedUserID()
	case chatrecords.FieldBotID:
		return m.AddedBotID()
	case chatrecords.FieldBotType:
		return m.AddedBotType()
	}
	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 *ChatRecordsMutation) AddField(name string, value ent.Value) error {
	switch name {
	case chatrecords.FieldContentType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddContentType(v)
		return nil
	case chatrecords.FieldSessionID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSessionID(v)
		return nil
	case chatrecords.FieldUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUserID(v)
		return nil
	case chatrecords.FieldBotID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotID(v)
		return nil
	case chatrecords.FieldBotType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotType(v)
		return nil
	}
	return fmt.Errorf("unknown ChatRecords numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ChatRecordsMutation) 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 *ChatRecordsMutation) ClearField(name string) error {
	switch name {
	case chatrecords.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown ChatRecords 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 *ChatRecordsMutation) ResetField(name string) error {
	switch name {
	case chatrecords.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case chatrecords.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case chatrecords.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case chatrecords.FieldContent:
		m.ResetContent()
		return nil
	case chatrecords.FieldContentType:
		m.ResetContentType()
		return nil
	case chatrecords.FieldSessionID:
		m.ResetSessionID()
		return nil
	case chatrecords.FieldUserID:
		m.ResetUserID()
		return nil
	case chatrecords.FieldBotID:
		m.ResetBotID()
		return nil
	case chatrecords.FieldBotType:
		m.ResetBotType()
		return nil
	}
	return fmt.Errorf("unknown ChatRecords field %s", name)
}

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

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

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

// ChatSessionMutation represents an operation that mutates the ChatSession nodes in the graph.
type ChatSessionMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	name          *string
	user_id       *uint64
	adduser_id    *int64
	bot_id        *uint64
	addbot_id     *int64
	bot_type      *uint8
	addbot_type   *int8
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*ChatSession, error)
	predicates    []predicate.ChatSession
}

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

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

// newChatSessionMutation creates new mutation for the ChatSession entity.
func newChatSessionMutation(c config, op Op, opts ...chatsessionOption) *ChatSessionMutation {
	m := &ChatSessionMutation{
		config:        c,
		op:            op,
		typ:           TypeChatSession,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withChatSession sets the old ChatSession of the mutation.
func withChatSession(node *ChatSession) chatsessionOption {
	return func(m *ChatSessionMutation) {
		m.oldValue = func(context.Context) (*ChatSession, 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 ChatSessionMutation) 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 ChatSessionMutation) 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 ChatSession entities.
func (m *ChatSessionMutation) 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 *ChatSessionMutation) 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 *ChatSessionMutation) 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().ChatSession.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 *ChatSessionMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *ChatSessionMutation) 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 ChatSession entity.
// If the ChatSession 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 *ChatSessionMutation) 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 *ChatSessionMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[chatsession.FieldDeletedAt] = struct{}{}
}

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

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

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

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

// SetUserID sets the "user_id" field.
func (m *ChatSessionMutation) SetUserID(u uint64) {
	m.user_id = &u
	m.adduser_id = nil
}

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

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

// AddUserID adds u to the "user_id" field.
func (m *ChatSessionMutation) AddUserID(u int64) {
	if m.adduser_id != nil {
		*m.adduser_id += u
	} else {
		m.adduser_id = &u
	}
}

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

// ResetUserID resets all changes to the "user_id" field.
func (m *ChatSessionMutation) ResetUserID() {
	m.user_id = nil
	m.adduser_id = nil
}

// SetBotID sets the "bot_id" field.
func (m *ChatSessionMutation) SetBotID(u uint64) {
	m.bot_id = &u
	m.addbot_id = nil
}

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

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

// AddBotID adds u to the "bot_id" field.
func (m *ChatSessionMutation) AddBotID(u int64) {
	if m.addbot_id != nil {
		*m.addbot_id += u
	} else {
		m.addbot_id = &u
	}
}

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

// ResetBotID resets all changes to the "bot_id" field.
func (m *ChatSessionMutation) ResetBotID() {
	m.bot_id = nil
	m.addbot_id = nil
}

// SetBotType sets the "bot_type" field.
func (m *ChatSessionMutation) SetBotType(u uint8) {
	m.bot_type = &u
	m.addbot_type = nil
}

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

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

// AddBotType adds u to the "bot_type" field.
func (m *ChatSessionMutation) AddBotType(u int8) {
	if m.addbot_type != nil {
		*m.addbot_type += u
	} else {
		m.addbot_type = &u
	}
}

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

// ResetBotType resets all changes to the "bot_type" field.
func (m *ChatSessionMutation) ResetBotType() {
	m.bot_type = nil
	m.addbot_type = nil
}

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

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

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

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

// Type returns the node type of this mutation (ChatSession).
func (m *ChatSessionMutation) 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 *ChatSessionMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, chatsession.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, chatsession.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, chatsession.FieldDeletedAt)
	}
	if m.name != nil {
		fields = append(fields, chatsession.FieldName)
	}
	if m.user_id != nil {
		fields = append(fields, chatsession.FieldUserID)
	}
	if m.bot_id != nil {
		fields = append(fields, chatsession.FieldBotID)
	}
	if m.bot_type != nil {
		fields = append(fields, chatsession.FieldBotType)
	}
	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 *ChatSessionMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case chatsession.FieldCreatedAt:
		return m.CreatedAt()
	case chatsession.FieldUpdatedAt:
		return m.UpdatedAt()
	case chatsession.FieldDeletedAt:
		return m.DeletedAt()
	case chatsession.FieldName:
		return m.Name()
	case chatsession.FieldUserID:
		return m.UserID()
	case chatsession.FieldBotID:
		return m.BotID()
	case chatsession.FieldBotType:
		return m.BotType()
	}
	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 *ChatSessionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case chatsession.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case chatsession.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case chatsession.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case chatsession.FieldName:
		return m.OldName(ctx)
	case chatsession.FieldUserID:
		return m.OldUserID(ctx)
	case chatsession.FieldBotID:
		return m.OldBotID(ctx)
	case chatsession.FieldBotType:
		return m.OldBotType(ctx)
	}
	return nil, fmt.Errorf("unknown ChatSession 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 *ChatSessionMutation) SetField(name string, value ent.Value) error {
	switch name {
	case chatsession.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 chatsession.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 chatsession.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 chatsession.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case chatsession.FieldUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case chatsession.FieldBotID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case chatsession.FieldBotType:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotType(v)
		return nil
	}
	return fmt.Errorf("unknown ChatSession field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ChatSessionMutation) AddedFields() []string {
	var fields []string
	if m.adduser_id != nil {
		fields = append(fields, chatsession.FieldUserID)
	}
	if m.addbot_id != nil {
		fields = append(fields, chatsession.FieldBotID)
	}
	if m.addbot_type != nil {
		fields = append(fields, chatsession.FieldBotType)
	}
	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 *ChatSessionMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case chatsession.FieldUserID:
		return m.AddedUserID()
	case chatsession.FieldBotID:
		return m.AddedBotID()
	case chatsession.FieldBotType:
		return m.AddedBotType()
	}
	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 *ChatSessionMutation) AddField(name string, value ent.Value) error {
	switch name {
	case chatsession.FieldUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUserID(v)
		return nil
	case chatsession.FieldBotID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotID(v)
		return nil
	case chatsession.FieldBotType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotType(v)
		return nil
	}
	return fmt.Errorf("unknown ChatSession numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ChatSessionMutation) 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 *ChatSessionMutation) ClearField(name string) error {
	switch name {
	case chatsession.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown ChatSession 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 *ChatSessionMutation) ResetField(name string) error {
	switch name {
	case chatsession.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case chatsession.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case chatsession.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case chatsession.FieldName:
		m.ResetName()
		return nil
	case chatsession.FieldUserID:
		m.ResetUserID()
		return nil
	case chatsession.FieldBotID:
		m.ResetBotID()
		return nil
	case chatsession.FieldBotType:
		m.ResetBotType()
		return nil
	}
	return fmt.Errorf("unknown ChatSession field %s", name)
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ChatSessionMutation) 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 *ChatSessionMutation) 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 *ChatSessionMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown ChatSession 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 *ChatSessionMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown ChatSession 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
	organization_id              *uint64
	addorganization_id           *int64
	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
}

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

// 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
}

// SetOrganizationID sets the "organization_id" field.
func (m *ContactMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *ContactMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[contact.FieldOrganizationID] = struct{}{}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *ContactMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, contact.FieldOrganizationID)
}

// 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, 20)
	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)
	}
	if m.organization_id != nil {
		fields = append(fields, contact.FieldOrganizationID)
	}
	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()
	case contact.FieldOrganizationID:
		return m.OrganizationID()
	}
	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)
	case contact.FieldOrganizationID:
		return m.OldOrganizationID(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
	case contact.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, contact.FieldOrganizationID)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *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()
	case contact.FieldOrganizationID:
		return m.AddedOrganizationID()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case contact.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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.FieldType) {
		fields = append(fields, contact.FieldType)
	}
	if m.FieldCleared(contact.FieldOrganizationID) {
		fields = append(fields, contact.FieldOrganizationID)
	}
	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.FieldType:
		m.ClearType()
		return nil
	case contact.FieldOrganizationID:
		m.ClearOrganizationID()
		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
	case contact.FieldOrganizationID:
		m.ResetOrganizationID()
		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)
}

// EmployeeMutation represents an operation that mutates the Employee nodes in the graph.
type EmployeeMutation struct {
	config
	op                         Op
	typ                        string
	id                         *uint64
	created_at                 *time.Time
	updated_at                 *time.Time
	deleted_at                 *time.Time
	title                      *string
	avatar                     *string
	tags                       *string
	hire_count                 *int
	addhire_count              *int
	service_count              *int
	addservice_count           *int
	achievement_count          *int
	addachievement_count       *int
	intro                      *string
	estimate                   *string
	skill                      *string
	ability_type               *string
	scene                      *string
	switch_in                  *string
	video_url                  *string
	organization_id            *uint64
	addorganization_id         *int64
	category_id                *uint64
	addcategory_id             *int64
	api_base                   *string
	api_key                    *string
	ai_info                    *string
	is_vip                     *int
	addis_vip                  *int
	clearedFields              map[string]struct{}
	em_work_experiences        map[uint64]struct{}
	removedem_work_experiences map[uint64]struct{}
	clearedem_work_experiences bool
	em_tutorial                map[uint64]struct{}
	removedem_tutorial         map[uint64]struct{}
	clearedem_tutorial         bool
	done                       bool
	oldValue                   func(context.Context) (*Employee, error)
	predicates                 []predicate.Employee
}

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

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

// newEmployeeMutation creates new mutation for the Employee entity.
func newEmployeeMutation(c config, op Op, opts ...employeeOption) *EmployeeMutation {
	m := &EmployeeMutation{
		config:        c,
		op:            op,
		typ:           TypeEmployee,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withEmployee sets the old Employee of the mutation.
func withEmployee(node *Employee) employeeOption {
	return func(m *EmployeeMutation) {
		m.oldValue = func(context.Context) (*Employee, 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 EmployeeMutation) 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 EmployeeMutation) 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 Employee entities.
func (m *EmployeeMutation) 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 *EmployeeMutation) 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 *EmployeeMutation) 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().Employee.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 *EmployeeMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *EmployeeMutation) 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 Employee entity.
// If the Employee 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 *EmployeeMutation) 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 *EmployeeMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[employee.FieldDeletedAt] = struct{}{}
}

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

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

// SetTitle sets the "title" field.
func (m *EmployeeMutation) SetTitle(s string) {
	m.title = &s
}

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

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

// ResetTitle resets all changes to the "title" field.
func (m *EmployeeMutation) ResetTitle() {
	m.title = nil
}

// SetAvatar sets the "avatar" field.
func (m *EmployeeMutation) SetAvatar(s string) {
	m.avatar = &s
}

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

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

// ResetAvatar resets all changes to the "avatar" field.
func (m *EmployeeMutation) ResetAvatar() {
	m.avatar = nil
}

// SetTags sets the "tags" field.
func (m *EmployeeMutation) SetTags(s string) {
	m.tags = &s
}

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

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

// ResetTags resets all changes to the "tags" field.
func (m *EmployeeMutation) ResetTags() {
	m.tags = nil
}

// SetHireCount sets the "hire_count" field.
func (m *EmployeeMutation) SetHireCount(i int) {
	m.hire_count = &i
	m.addhire_count = nil
}

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

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

// AddHireCount adds i to the "hire_count" field.
func (m *EmployeeMutation) AddHireCount(i int) {
	if m.addhire_count != nil {
		*m.addhire_count += i
	} else {
		m.addhire_count = &i
	}
}

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

// ResetHireCount resets all changes to the "hire_count" field.
func (m *EmployeeMutation) ResetHireCount() {
	m.hire_count = nil
	m.addhire_count = nil
}

// SetServiceCount sets the "service_count" field.
func (m *EmployeeMutation) SetServiceCount(i int) {
	m.service_count = &i
	m.addservice_count = nil
}

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

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

// AddServiceCount adds i to the "service_count" field.
func (m *EmployeeMutation) AddServiceCount(i int) {
	if m.addservice_count != nil {
		*m.addservice_count += i
	} else {
		m.addservice_count = &i
	}
}

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

// ResetServiceCount resets all changes to the "service_count" field.
func (m *EmployeeMutation) ResetServiceCount() {
	m.service_count = nil
	m.addservice_count = nil
}

// SetAchievementCount sets the "achievement_count" field.
func (m *EmployeeMutation) SetAchievementCount(i int) {
	m.achievement_count = &i
	m.addachievement_count = nil
}

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

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

// AddAchievementCount adds i to the "achievement_count" field.
func (m *EmployeeMutation) AddAchievementCount(i int) {
	if m.addachievement_count != nil {
		*m.addachievement_count += i
	} else {
		m.addachievement_count = &i
	}
}

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

// ResetAchievementCount resets all changes to the "achievement_count" field.
func (m *EmployeeMutation) ResetAchievementCount() {
	m.achievement_count = nil
	m.addachievement_count = nil
}

// SetIntro sets the "intro" field.
func (m *EmployeeMutation) SetIntro(s string) {
	m.intro = &s
}

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

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

// ResetIntro resets all changes to the "intro" field.
func (m *EmployeeMutation) ResetIntro() {
	m.intro = nil
}

// SetEstimate sets the "estimate" field.
func (m *EmployeeMutation) SetEstimate(s string) {
	m.estimate = &s
}

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

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

// ResetEstimate resets all changes to the "estimate" field.
func (m *EmployeeMutation) ResetEstimate() {
	m.estimate = nil
}

// SetSkill sets the "skill" field.
func (m *EmployeeMutation) SetSkill(s string) {
	m.skill = &s
}

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

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

// ResetSkill resets all changes to the "skill" field.
func (m *EmployeeMutation) ResetSkill() {
	m.skill = nil
}

// SetAbilityType sets the "ability_type" field.
func (m *EmployeeMutation) SetAbilityType(s string) {
	m.ability_type = &s
}

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

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

// ResetAbilityType resets all changes to the "ability_type" field.
func (m *EmployeeMutation) ResetAbilityType() {
	m.ability_type = nil
}

// SetScene sets the "scene" field.
func (m *EmployeeMutation) SetScene(s string) {
	m.scene = &s
}

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

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

// ResetScene resets all changes to the "scene" field.
func (m *EmployeeMutation) ResetScene() {
	m.scene = nil
}

// SetSwitchIn sets the "switch_in" field.
func (m *EmployeeMutation) SetSwitchIn(s string) {
	m.switch_in = &s
}

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

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

// ResetSwitchIn resets all changes to the "switch_in" field.
func (m *EmployeeMutation) ResetSwitchIn() {
	m.switch_in = nil
}

// SetVideoURL sets the "video_url" field.
func (m *EmployeeMutation) SetVideoURL(s string) {
	m.video_url = &s
}

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

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

// ResetVideoURL resets all changes to the "video_url" field.
func (m *EmployeeMutation) ResetVideoURL() {
	m.video_url = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *EmployeeMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

// SetCategoryID sets the "category_id" field.
func (m *EmployeeMutation) SetCategoryID(u uint64) {
	m.category_id = &u
	m.addcategory_id = nil
}

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

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

// AddCategoryID adds u to the "category_id" field.
func (m *EmployeeMutation) AddCategoryID(u int64) {
	if m.addcategory_id != nil {
		*m.addcategory_id += u
	} else {
		m.addcategory_id = &u
	}
}

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

// ResetCategoryID resets all changes to the "category_id" field.
func (m *EmployeeMutation) ResetCategoryID() {
	m.category_id = nil
	m.addcategory_id = nil
}

// SetAPIBase sets the "api_base" field.
func (m *EmployeeMutation) SetAPIBase(s string) {
	m.api_base = &s
}

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

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

// ResetAPIBase resets all changes to the "api_base" field.
func (m *EmployeeMutation) ResetAPIBase() {
	m.api_base = nil
}

// SetAPIKey sets the "api_key" field.
func (m *EmployeeMutation) SetAPIKey(s string) {
	m.api_key = &s
}

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

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

// ResetAPIKey resets all changes to the "api_key" field.
func (m *EmployeeMutation) ResetAPIKey() {
	m.api_key = nil
}

// SetAiInfo sets the "ai_info" field.
func (m *EmployeeMutation) SetAiInfo(s string) {
	m.ai_info = &s
}

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

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

// ClearAiInfo clears the value of the "ai_info" field.
func (m *EmployeeMutation) ClearAiInfo() {
	m.ai_info = nil
	m.clearedFields[employee.FieldAiInfo] = struct{}{}
}

// AiInfoCleared returns if the "ai_info" field was cleared in this mutation.
func (m *EmployeeMutation) AiInfoCleared() bool {
	_, ok := m.clearedFields[employee.FieldAiInfo]
	return ok
}

// ResetAiInfo resets all changes to the "ai_info" field.
func (m *EmployeeMutation) ResetAiInfo() {
	m.ai_info = nil
	delete(m.clearedFields, employee.FieldAiInfo)
}

// SetIsVip sets the "is_vip" field.
func (m *EmployeeMutation) SetIsVip(i int) {
	m.is_vip = &i
	m.addis_vip = nil
}

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

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

// AddIsVip adds i to the "is_vip" field.
func (m *EmployeeMutation) AddIsVip(i int) {
	if m.addis_vip != nil {
		*m.addis_vip += i
	} else {
		m.addis_vip = &i
	}
}

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

// ResetIsVip resets all changes to the "is_vip" field.
func (m *EmployeeMutation) ResetIsVip() {
	m.is_vip = nil
	m.addis_vip = nil
}

// AddEmWorkExperienceIDs adds the "em_work_experiences" edge to the WorkExperience entity by ids.
func (m *EmployeeMutation) AddEmWorkExperienceIDs(ids ...uint64) {
	if m.em_work_experiences == nil {
		m.em_work_experiences = make(map[uint64]struct{})
	}
	for i := range ids {
		m.em_work_experiences[ids[i]] = struct{}{}
	}
}

// ClearEmWorkExperiences clears the "em_work_experiences" edge to the WorkExperience entity.
func (m *EmployeeMutation) ClearEmWorkExperiences() {
	m.clearedem_work_experiences = true
}

// EmWorkExperiencesCleared reports if the "em_work_experiences" edge to the WorkExperience entity was cleared.
func (m *EmployeeMutation) EmWorkExperiencesCleared() bool {
	return m.clearedem_work_experiences
}

// RemoveEmWorkExperienceIDs removes the "em_work_experiences" edge to the WorkExperience entity by IDs.
func (m *EmployeeMutation) RemoveEmWorkExperienceIDs(ids ...uint64) {
	if m.removedem_work_experiences == nil {
		m.removedem_work_experiences = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.em_work_experiences, ids[i])
		m.removedem_work_experiences[ids[i]] = struct{}{}
	}
}

// RemovedEmWorkExperiences returns the removed IDs of the "em_work_experiences" edge to the WorkExperience entity.
func (m *EmployeeMutation) RemovedEmWorkExperiencesIDs() (ids []uint64) {
	for id := range m.removedem_work_experiences {
		ids = append(ids, id)
	}
	return
}

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

// ResetEmWorkExperiences resets all changes to the "em_work_experiences" edge.
func (m *EmployeeMutation) ResetEmWorkExperiences() {
	m.em_work_experiences = nil
	m.clearedem_work_experiences = false
	m.removedem_work_experiences = nil
}

// AddEmTutorialIDs adds the "em_tutorial" edge to the Tutorial entity by ids.
func (m *EmployeeMutation) AddEmTutorialIDs(ids ...uint64) {
	if m.em_tutorial == nil {
		m.em_tutorial = make(map[uint64]struct{})
	}
	for i := range ids {
		m.em_tutorial[ids[i]] = struct{}{}
	}
}

// ClearEmTutorial clears the "em_tutorial" edge to the Tutorial entity.
func (m *EmployeeMutation) ClearEmTutorial() {
	m.clearedem_tutorial = true
}

// EmTutorialCleared reports if the "em_tutorial" edge to the Tutorial entity was cleared.
func (m *EmployeeMutation) EmTutorialCleared() bool {
	return m.clearedem_tutorial
}

// RemoveEmTutorialIDs removes the "em_tutorial" edge to the Tutorial entity by IDs.
func (m *EmployeeMutation) RemoveEmTutorialIDs(ids ...uint64) {
	if m.removedem_tutorial == nil {
		m.removedem_tutorial = make(map[uint64]struct{})
	}
	for i := range ids {
		delete(m.em_tutorial, ids[i])
		m.removedem_tutorial[ids[i]] = struct{}{}
	}
}

// RemovedEmTutorial returns the removed IDs of the "em_tutorial" edge to the Tutorial entity.
func (m *EmployeeMutation) RemovedEmTutorialIDs() (ids []uint64) {
	for id := range m.removedem_tutorial {
		ids = append(ids, id)
	}
	return
}

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

// ResetEmTutorial resets all changes to the "em_tutorial" edge.
func (m *EmployeeMutation) ResetEmTutorial() {
	m.em_tutorial = nil
	m.clearedem_tutorial = false
	m.removedem_tutorial = nil
}

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

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

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

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

// Type returns the node type of this mutation (Employee).
func (m *EmployeeMutation) 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 *EmployeeMutation) Fields() []string {
	fields := make([]string, 0, 22)
	if m.created_at != nil {
		fields = append(fields, employee.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, employee.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, employee.FieldDeletedAt)
	}
	if m.title != nil {
		fields = append(fields, employee.FieldTitle)
	}
	if m.avatar != nil {
		fields = append(fields, employee.FieldAvatar)
	}
	if m.tags != nil {
		fields = append(fields, employee.FieldTags)
	}
	if m.hire_count != nil {
		fields = append(fields, employee.FieldHireCount)
	}
	if m.service_count != nil {
		fields = append(fields, employee.FieldServiceCount)
	}
	if m.achievement_count != nil {
		fields = append(fields, employee.FieldAchievementCount)
	}
	if m.intro != nil {
		fields = append(fields, employee.FieldIntro)
	}
	if m.estimate != nil {
		fields = append(fields, employee.FieldEstimate)
	}
	if m.skill != nil {
		fields = append(fields, employee.FieldSkill)
	}
	if m.ability_type != nil {
		fields = append(fields, employee.FieldAbilityType)
	}
	if m.scene != nil {
		fields = append(fields, employee.FieldScene)
	}
	if m.switch_in != nil {
		fields = append(fields, employee.FieldSwitchIn)
	}
	if m.video_url != nil {
		fields = append(fields, employee.FieldVideoURL)
	}
	if m.organization_id != nil {
		fields = append(fields, employee.FieldOrganizationID)
	}
	if m.category_id != nil {
		fields = append(fields, employee.FieldCategoryID)
	}
	if m.api_base != nil {
		fields = append(fields, employee.FieldAPIBase)
	}
	if m.api_key != nil {
		fields = append(fields, employee.FieldAPIKey)
	}
	if m.ai_info != nil {
		fields = append(fields, employee.FieldAiInfo)
	}
	if m.is_vip != nil {
		fields = append(fields, employee.FieldIsVip)
	}
	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 *EmployeeMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case employee.FieldCreatedAt:
		return m.CreatedAt()
	case employee.FieldUpdatedAt:
		return m.UpdatedAt()
	case employee.FieldDeletedAt:
		return m.DeletedAt()
	case employee.FieldTitle:
		return m.Title()
	case employee.FieldAvatar:
		return m.Avatar()
	case employee.FieldTags:
		return m.Tags()
	case employee.FieldHireCount:
		return m.HireCount()
	case employee.FieldServiceCount:
		return m.ServiceCount()
	case employee.FieldAchievementCount:
		return m.AchievementCount()
	case employee.FieldIntro:
		return m.Intro()
	case employee.FieldEstimate:
		return m.Estimate()
	case employee.FieldSkill:
		return m.Skill()
	case employee.FieldAbilityType:
		return m.AbilityType()
	case employee.FieldScene:
		return m.Scene()
	case employee.FieldSwitchIn:
		return m.SwitchIn()
	case employee.FieldVideoURL:
		return m.VideoURL()
	case employee.FieldOrganizationID:
		return m.OrganizationID()
	case employee.FieldCategoryID:
		return m.CategoryID()
	case employee.FieldAPIBase:
		return m.APIBase()
	case employee.FieldAPIKey:
		return m.APIKey()
	case employee.FieldAiInfo:
		return m.AiInfo()
	case employee.FieldIsVip:
		return m.IsVip()
	}
	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 *EmployeeMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case employee.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case employee.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case employee.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case employee.FieldTitle:
		return m.OldTitle(ctx)
	case employee.FieldAvatar:
		return m.OldAvatar(ctx)
	case employee.FieldTags:
		return m.OldTags(ctx)
	case employee.FieldHireCount:
		return m.OldHireCount(ctx)
	case employee.FieldServiceCount:
		return m.OldServiceCount(ctx)
	case employee.FieldAchievementCount:
		return m.OldAchievementCount(ctx)
	case employee.FieldIntro:
		return m.OldIntro(ctx)
	case employee.FieldEstimate:
		return m.OldEstimate(ctx)
	case employee.FieldSkill:
		return m.OldSkill(ctx)
	case employee.FieldAbilityType:
		return m.OldAbilityType(ctx)
	case employee.FieldScene:
		return m.OldScene(ctx)
	case employee.FieldSwitchIn:
		return m.OldSwitchIn(ctx)
	case employee.FieldVideoURL:
		return m.OldVideoURL(ctx)
	case employee.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case employee.FieldCategoryID:
		return m.OldCategoryID(ctx)
	case employee.FieldAPIBase:
		return m.OldAPIBase(ctx)
	case employee.FieldAPIKey:
		return m.OldAPIKey(ctx)
	case employee.FieldAiInfo:
		return m.OldAiInfo(ctx)
	case employee.FieldIsVip:
		return m.OldIsVip(ctx)
	}
	return nil, fmt.Errorf("unknown Employee 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 *EmployeeMutation) SetField(name string, value ent.Value) error {
	switch name {
	case employee.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 employee.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 employee.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 employee.FieldTitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTitle(v)
		return nil
	case employee.FieldAvatar:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatar(v)
		return nil
	case employee.FieldTags:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTags(v)
		return nil
	case employee.FieldHireCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHireCount(v)
		return nil
	case employee.FieldServiceCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetServiceCount(v)
		return nil
	case employee.FieldAchievementCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAchievementCount(v)
		return nil
	case employee.FieldIntro:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIntro(v)
		return nil
	case employee.FieldEstimate:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEstimate(v)
		return nil
	case employee.FieldSkill:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSkill(v)
		return nil
	case employee.FieldAbilityType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAbilityType(v)
		return nil
	case employee.FieldScene:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetScene(v)
		return nil
	case employee.FieldSwitchIn:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSwitchIn(v)
		return nil
	case employee.FieldVideoURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVideoURL(v)
		return nil
	case employee.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case employee.FieldCategoryID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCategoryID(v)
		return nil
	case employee.FieldAPIBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIBase(v)
		return nil
	case employee.FieldAPIKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIKey(v)
		return nil
	case employee.FieldAiInfo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAiInfo(v)
		return nil
	case employee.FieldIsVip:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsVip(v)
		return nil
	}
	return fmt.Errorf("unknown Employee field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *EmployeeMutation) AddedFields() []string {
	var fields []string
	if m.addhire_count != nil {
		fields = append(fields, employee.FieldHireCount)
	}
	if m.addservice_count != nil {
		fields = append(fields, employee.FieldServiceCount)
	}
	if m.addachievement_count != nil {
		fields = append(fields, employee.FieldAchievementCount)
	}
	if m.addorganization_id != nil {
		fields = append(fields, employee.FieldOrganizationID)
	}
	if m.addcategory_id != nil {
		fields = append(fields, employee.FieldCategoryID)
	}
	if m.addis_vip != nil {
		fields = append(fields, employee.FieldIsVip)
	}
	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 *EmployeeMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case employee.FieldHireCount:
		return m.AddedHireCount()
	case employee.FieldServiceCount:
		return m.AddedServiceCount()
	case employee.FieldAchievementCount:
		return m.AddedAchievementCount()
	case employee.FieldOrganizationID:
		return m.AddedOrganizationID()
	case employee.FieldCategoryID:
		return m.AddedCategoryID()
	case employee.FieldIsVip:
		return m.AddedIsVip()
	}
	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 *EmployeeMutation) AddField(name string, value ent.Value) error {
	switch name {
	case employee.FieldHireCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddHireCount(v)
		return nil
	case employee.FieldServiceCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddServiceCount(v)
		return nil
	case employee.FieldAchievementCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAchievementCount(v)
		return nil
	case employee.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case employee.FieldCategoryID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCategoryID(v)
		return nil
	case employee.FieldIsVip:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddIsVip(v)
		return nil
	}
	return fmt.Errorf("unknown Employee numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *EmployeeMutation) 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 *EmployeeMutation) ClearField(name string) error {
	switch name {
	case employee.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case employee.FieldAiInfo:
		m.ClearAiInfo()
		return nil
	}
	return fmt.Errorf("unknown Employee 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 *EmployeeMutation) ResetField(name string) error {
	switch name {
	case employee.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case employee.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case employee.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case employee.FieldTitle:
		m.ResetTitle()
		return nil
	case employee.FieldAvatar:
		m.ResetAvatar()
		return nil
	case employee.FieldTags:
		m.ResetTags()
		return nil
	case employee.FieldHireCount:
		m.ResetHireCount()
		return nil
	case employee.FieldServiceCount:
		m.ResetServiceCount()
		return nil
	case employee.FieldAchievementCount:
		m.ResetAchievementCount()
		return nil
	case employee.FieldIntro:
		m.ResetIntro()
		return nil
	case employee.FieldEstimate:
		m.ResetEstimate()
		return nil
	case employee.FieldSkill:
		m.ResetSkill()
		return nil
	case employee.FieldAbilityType:
		m.ResetAbilityType()
		return nil
	case employee.FieldScene:
		m.ResetScene()
		return nil
	case employee.FieldSwitchIn:
		m.ResetSwitchIn()
		return nil
	case employee.FieldVideoURL:
		m.ResetVideoURL()
		return nil
	case employee.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case employee.FieldCategoryID:
		m.ResetCategoryID()
		return nil
	case employee.FieldAPIBase:
		m.ResetAPIBase()
		return nil
	case employee.FieldAPIKey:
		m.ResetAPIKey()
		return nil
	case employee.FieldAiInfo:
		m.ResetAiInfo()
		return nil
	case employee.FieldIsVip:
		m.ResetIsVip()
		return nil
	}
	return fmt.Errorf("unknown Employee field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *EmployeeMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.em_work_experiences != nil {
		edges = append(edges, employee.EdgeEmWorkExperiences)
	}
	if m.em_tutorial != nil {
		edges = append(edges, employee.EdgeEmTutorial)
	}
	return edges
}

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

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *EmployeeMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedem_work_experiences != nil {
		edges = append(edges, employee.EdgeEmWorkExperiences)
	}
	if m.removedem_tutorial != nil {
		edges = append(edges, employee.EdgeEmTutorial)
	}
	return edges
}

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *EmployeeMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedem_work_experiences {
		edges = append(edges, employee.EdgeEmWorkExperiences)
	}
	if m.clearedem_tutorial {
		edges = append(edges, employee.EdgeEmTutorial)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *EmployeeMutation) EdgeCleared(name string) bool {
	switch name {
	case employee.EdgeEmWorkExperiences:
		return m.clearedem_work_experiences
	case employee.EdgeEmTutorial:
		return m.clearedem_tutorial
	}
	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 *EmployeeMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Employee 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 *EmployeeMutation) ResetEdge(name string) error {
	switch name {
	case employee.EdgeEmWorkExperiences:
		m.ResetEmWorkExperiences()
		return nil
	case employee.EdgeEmTutorial:
		m.ResetEmTutorial()
		return nil
	}
	return fmt.Errorf("unknown Employee edge %s", name)
}

// EmployeeConfigMutation represents an operation that mutates the EmployeeConfig nodes in the graph.
type EmployeeConfigMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	stype              *string
	title              *string
	photo              *string
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*EmployeeConfig, error)
	predicates         []predicate.EmployeeConfig
}

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

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

// newEmployeeConfigMutation creates new mutation for the EmployeeConfig entity.
func newEmployeeConfigMutation(c config, op Op, opts ...employeeconfigOption) *EmployeeConfigMutation {
	m := &EmployeeConfigMutation{
		config:        c,
		op:            op,
		typ:           TypeEmployeeConfig,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withEmployeeConfig sets the old EmployeeConfig of the mutation.
func withEmployeeConfig(node *EmployeeConfig) employeeconfigOption {
	return func(m *EmployeeConfigMutation) {
		m.oldValue = func(context.Context) (*EmployeeConfig, 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 EmployeeConfigMutation) 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 EmployeeConfigMutation) 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 EmployeeConfig entities.
func (m *EmployeeConfigMutation) 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 *EmployeeConfigMutation) 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 *EmployeeConfigMutation) 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().EmployeeConfig.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 *EmployeeConfigMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *EmployeeConfigMutation) 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 EmployeeConfig entity.
// If the EmployeeConfig 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 *EmployeeConfigMutation) 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 *EmployeeConfigMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[employeeconfig.FieldDeletedAt] = struct{}{}
}

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

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

// SetStype sets the "stype" field.
func (m *EmployeeConfigMutation) SetStype(s string) {
	m.stype = &s
}

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

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

// ResetStype resets all changes to the "stype" field.
func (m *EmployeeConfigMutation) ResetStype() {
	m.stype = nil
}

// SetTitle sets the "title" field.
func (m *EmployeeConfigMutation) SetTitle(s string) {
	m.title = &s
}

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

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

// ResetTitle resets all changes to the "title" field.
func (m *EmployeeConfigMutation) ResetTitle() {
	m.title = nil
}

// SetPhoto sets the "photo" field.
func (m *EmployeeConfigMutation) SetPhoto(s string) {
	m.photo = &s
}

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

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

// ResetPhoto resets all changes to the "photo" field.
func (m *EmployeeConfigMutation) ResetPhoto() {
	m.photo = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *EmployeeConfigMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *EmployeeConfigMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[employeeconfig.FieldOrganizationID] = struct{}{}
}

// OrganizationIDCleared returns if the "organization_id" field was cleared in this mutation.
func (m *EmployeeConfigMutation) OrganizationIDCleared() bool {
	_, ok := m.clearedFields[employeeconfig.FieldOrganizationID]
	return ok
}

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *EmployeeConfigMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, employeeconfig.FieldOrganizationID)
}

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

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

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

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

// Type returns the node type of this mutation (EmployeeConfig).
func (m *EmployeeConfigMutation) 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 *EmployeeConfigMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, employeeconfig.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, employeeconfig.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, employeeconfig.FieldDeletedAt)
	}
	if m.stype != nil {
		fields = append(fields, employeeconfig.FieldStype)
	}
	if m.title != nil {
		fields = append(fields, employeeconfig.FieldTitle)
	}
	if m.photo != nil {
		fields = append(fields, employeeconfig.FieldPhoto)
	}
	if m.organization_id != nil {
		fields = append(fields, employeeconfig.FieldOrganizationID)
	}
	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 *EmployeeConfigMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case employeeconfig.FieldCreatedAt:
		return m.CreatedAt()
	case employeeconfig.FieldUpdatedAt:
		return m.UpdatedAt()
	case employeeconfig.FieldDeletedAt:
		return m.DeletedAt()
	case employeeconfig.FieldStype:
		return m.Stype()
	case employeeconfig.FieldTitle:
		return m.Title()
	case employeeconfig.FieldPhoto:
		return m.Photo()
	case employeeconfig.FieldOrganizationID:
		return m.OrganizationID()
	}
	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 *EmployeeConfigMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case employeeconfig.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case employeeconfig.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case employeeconfig.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case employeeconfig.FieldStype:
		return m.OldStype(ctx)
	case employeeconfig.FieldTitle:
		return m.OldTitle(ctx)
	case employeeconfig.FieldPhoto:
		return m.OldPhoto(ctx)
	case employeeconfig.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown EmployeeConfig 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 *EmployeeConfigMutation) SetField(name string, value ent.Value) error {
	switch name {
	case employeeconfig.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 employeeconfig.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 employeeconfig.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 employeeconfig.FieldStype:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStype(v)
		return nil
	case employeeconfig.FieldTitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTitle(v)
		return nil
	case employeeconfig.FieldPhoto:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhoto(v)
		return nil
	case employeeconfig.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown EmployeeConfig field %s", name)
}

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

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

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *EmployeeConfigMutation) 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 *EmployeeConfigMutation) ClearField(name string) error {
	switch name {
	case employeeconfig.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case employeeconfig.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown EmployeeConfig 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 *EmployeeConfigMutation) ResetField(name string) error {
	switch name {
	case employeeconfig.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case employeeconfig.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case employeeconfig.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case employeeconfig.FieldStype:
		m.ResetStype()
		return nil
	case employeeconfig.FieldTitle:
		m.ResetTitle()
		return nil
	case employeeconfig.FieldPhoto:
		m.ResetPhoto()
		return nil
	case employeeconfig.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown EmployeeConfig field %s", name)
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *EmployeeConfigMutation) 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 *EmployeeConfigMutation) 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 *EmployeeConfigMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown EmployeeConfig 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 *EmployeeConfigMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown EmployeeConfig 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
	_type                      *int
	add_type                   *int
	name                       *string
	from                       *int
	addfrom                    *int
	mode                       *int
	addmode                    *int
	conditions                 *string
	organization_id            *uint64
	addorganization_id         *int64
	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)
}

// 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)
}

// SetOrganizationID sets the "organization_id" field.
func (m *LabelMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *LabelMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[label.FieldOrganizationID] = struct{}{}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *LabelMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, label.FieldOrganizationID)
}

// 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._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)
	}
	if m.organization_id != nil {
		fields = append(fields, label.FieldOrganizationID)
	}
	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.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()
	case label.FieldOrganizationID:
		return m.OrganizationID()
	}
	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.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)
	case label.FieldOrganizationID:
		return m.OldOrganizationID(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.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
	case label.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, label.FieldOrganizationID)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *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()
	case label.FieldOrganizationID:
		return m.AddedOrganizationID()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case label.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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.FieldConditions) {
		fields = append(fields, label.FieldConditions)
	}
	if m.FieldCleared(label.FieldOrganizationID) {
		fields = append(fields, label.FieldOrganizationID)
	}
	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.FieldConditions:
		m.ClearConditions()
		return nil
	case label.FieldOrganizationID:
		m.ClearOrganizationID()
		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.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
	case label.FieldOrganizationID:
		m.ResetOrganizationID()
		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
	organization_id    *uint64
	addorganization_id *int64
	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
}

// SetOrganizationID sets the "organization_id" field.
func (m *LabelRelationshipMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *LabelRelationshipMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[labelrelationship.FieldOrganizationID] = struct{}{}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *LabelRelationshipMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, labelrelationship.FieldOrganizationID)
}

// 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, 7)
	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)
	}
	if m.organization_id != nil {
		fields = append(fields, labelrelationship.FieldOrganizationID)
	}
	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()
	case labelrelationship.FieldOrganizationID:
		return m.OrganizationID()
	}
	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)
	case labelrelationship.FieldOrganizationID:
		return m.OldOrganizationID(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
	case labelrelationship.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, labelrelationship.FieldOrganizationID)
	}
	return fields
}

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

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case labelrelationship.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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)
	}
	if m.FieldCleared(labelrelationship.FieldOrganizationID) {
		fields = append(fields, labelrelationship.FieldOrganizationID)
	}
	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
	case labelrelationship.FieldOrganizationID:
		m.ClearOrganizationID()
		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
	case labelrelationship.FieldOrganizationID:
		m.ResetOrganizationID()
		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
	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
	organization_id        *uint64
	addorganization_id     *int64
	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)
}

// 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)
}

// SetOrganizationID sets the "organization_id" field.
func (m *MessageRecordsMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *MessageRecordsMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[messagerecords.FieldOrganizationID] = struct{}{}
}

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

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *MessageRecordsMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, messagerecords.FieldOrganizationID)
}

// 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.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)
	}
	if m.organization_id != nil {
		fields = append(fields, messagerecords.FieldOrganizationID)
	}
	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.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()
	case messagerecords.FieldOrganizationID:
		return m.OrganizationID()
	}
	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.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)
	case messagerecords.FieldOrganizationID:
		return m.OldOrganizationID(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.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
	case messagerecords.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, messagerecords.FieldOrganizationID)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *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()
	case messagerecords.FieldOrganizationID:
		return m.AddedOrganizationID()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case messagerecords.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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.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)
	}
	if m.FieldCleared(messagerecords.FieldOrganizationID) {
		fields = append(fields, messagerecords.FieldOrganizationID)
	}
	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.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
	case messagerecords.FieldOrganizationID:
		m.ClearOrganizationID()
		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.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
	case messagerecords.FieldOrganizationID:
		m.ResetOrganizationID()
		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)
}

// MsgMutation represents an operation that mutates the Msg nodes in the graph.
type MsgMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	status        *uint8
	addstatus     *int8
	fromwxid      *string
	toid          *string
	msgtype       *int32
	addmsgtype    *int32
	msg           *string
	batch_no      *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Msg, error)
	predicates    []predicate.Msg
}

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

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

// newMsgMutation creates new mutation for the Msg entity.
func newMsgMutation(c config, op Op, opts ...msgOption) *MsgMutation {
	m := &MsgMutation{
		config:        c,
		op:            op,
		typ:           TypeMsg,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withMsg sets the old Msg of the mutation.
func withMsg(node *Msg) msgOption {
	return func(m *MsgMutation) {
		m.oldValue = func(context.Context) (*Msg, 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 MsgMutation) 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 MsgMutation) 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 Msg entities.
func (m *MsgMutation) 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 *MsgMutation) 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 *MsgMutation) 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().Msg.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 *MsgMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *MsgMutation) 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 Msg entity.
// If the Msg 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 *MsgMutation) 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 *MsgMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[msg.FieldDeletedAt] = struct{}{}
}

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

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

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

// Status returns the value of the "status" field in the mutation.
func (m *MsgMutation) 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 Msg entity.
// If the Msg 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 *MsgMutation) 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 *MsgMutation) 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 *MsgMutation) 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 *MsgMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[msg.FieldStatus] = struct{}{}
}

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

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

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

// Fromwxid returns the value of the "fromwxid" field in the mutation.
func (m *MsgMutation) 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 Msg entity.
// If the Msg 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 *MsgMutation) 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 *MsgMutation) ClearFromwxid() {
	m.fromwxid = nil
	m.clearedFields[msg.FieldFromwxid] = struct{}{}
}

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

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

// SetToid sets the "toid" field.
func (m *MsgMutation) SetToid(s string) {
	m.toid = &s
}

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

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

// ClearToid clears the value of the "toid" field.
func (m *MsgMutation) ClearToid() {
	m.toid = nil
	m.clearedFields[msg.FieldToid] = struct{}{}
}

// ToidCleared returns if the "toid" field was cleared in this mutation.
func (m *MsgMutation) ToidCleared() bool {
	_, ok := m.clearedFields[msg.FieldToid]
	return ok
}

// ResetToid resets all changes to the "toid" field.
func (m *MsgMutation) ResetToid() {
	m.toid = nil
	delete(m.clearedFields, msg.FieldToid)
}

// SetMsgtype sets the "msgtype" field.
func (m *MsgMutation) SetMsgtype(i int32) {
	m.msgtype = &i
	m.addmsgtype = nil
}

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

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

// AddMsgtype adds i to the "msgtype" field.
func (m *MsgMutation) AddMsgtype(i int32) {
	if m.addmsgtype != nil {
		*m.addmsgtype += i
	} else {
		m.addmsgtype = &i
	}
}

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

// ClearMsgtype clears the value of the "msgtype" field.
func (m *MsgMutation) ClearMsgtype() {
	m.msgtype = nil
	m.addmsgtype = nil
	m.clearedFields[msg.FieldMsgtype] = struct{}{}
}

// MsgtypeCleared returns if the "msgtype" field was cleared in this mutation.
func (m *MsgMutation) MsgtypeCleared() bool {
	_, ok := m.clearedFields[msg.FieldMsgtype]
	return ok
}

// ResetMsgtype resets all changes to the "msgtype" field.
func (m *MsgMutation) ResetMsgtype() {
	m.msgtype = nil
	m.addmsgtype = nil
	delete(m.clearedFields, msg.FieldMsgtype)
}

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

// Msg returns the value of the "msg" field in the mutation.
func (m *MsgMutation) 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 Msg entity.
// If the Msg 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 *MsgMutation) 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 *MsgMutation) ClearMsg() {
	m.msg = nil
	m.clearedFields[msg.FieldMsg] = struct{}{}
}

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

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

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

// BatchNo returns the value of the "batch_no" field in the mutation.
func (m *MsgMutation) 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 Msg entity.
// If the Msg 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 *MsgMutation) 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 *MsgMutation) ClearBatchNo() {
	m.batch_no = nil
	m.clearedFields[msg.FieldBatchNo] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (Msg).
func (m *MsgMutation) 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 *MsgMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, msg.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, msg.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, msg.FieldDeletedAt)
	}
	if m.status != nil {
		fields = append(fields, msg.FieldStatus)
	}
	if m.fromwxid != nil {
		fields = append(fields, msg.FieldFromwxid)
	}
	if m.toid != nil {
		fields = append(fields, msg.FieldToid)
	}
	if m.msgtype != nil {
		fields = append(fields, msg.FieldMsgtype)
	}
	if m.msg != nil {
		fields = append(fields, msg.FieldMsg)
	}
	if m.batch_no != nil {
		fields = append(fields, msg.FieldBatchNo)
	}
	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 *MsgMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case msg.FieldCreatedAt:
		return m.CreatedAt()
	case msg.FieldUpdatedAt:
		return m.UpdatedAt()
	case msg.FieldDeletedAt:
		return m.DeletedAt()
	case msg.FieldStatus:
		return m.Status()
	case msg.FieldFromwxid:
		return m.Fromwxid()
	case msg.FieldToid:
		return m.Toid()
	case msg.FieldMsgtype:
		return m.Msgtype()
	case msg.FieldMsg:
		return m.Msg()
	case msg.FieldBatchNo:
		return m.BatchNo()
	}
	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 *MsgMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case msg.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case msg.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case msg.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case msg.FieldStatus:
		return m.OldStatus(ctx)
	case msg.FieldFromwxid:
		return m.OldFromwxid(ctx)
	case msg.FieldToid:
		return m.OldToid(ctx)
	case msg.FieldMsgtype:
		return m.OldMsgtype(ctx)
	case msg.FieldMsg:
		return m.OldMsg(ctx)
	case msg.FieldBatchNo:
		return m.OldBatchNo(ctx)
	}
	return nil, fmt.Errorf("unknown Msg 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 *MsgMutation) SetField(name string, value ent.Value) error {
	switch name {
	case msg.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 msg.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 msg.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 msg.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case msg.FieldFromwxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFromwxid(v)
		return nil
	case msg.FieldToid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToid(v)
		return nil
	case msg.FieldMsgtype:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMsgtype(v)
		return nil
	case msg.FieldMsg:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMsg(v)
		return nil
	case msg.FieldBatchNo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBatchNo(v)
		return nil
	}
	return fmt.Errorf("unknown Msg field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *MsgMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(msg.FieldDeletedAt) {
		fields = append(fields, msg.FieldDeletedAt)
	}
	if m.FieldCleared(msg.FieldStatus) {
		fields = append(fields, msg.FieldStatus)
	}
	if m.FieldCleared(msg.FieldFromwxid) {
		fields = append(fields, msg.FieldFromwxid)
	}
	if m.FieldCleared(msg.FieldToid) {
		fields = append(fields, msg.FieldToid)
	}
	if m.FieldCleared(msg.FieldMsgtype) {
		fields = append(fields, msg.FieldMsgtype)
	}
	if m.FieldCleared(msg.FieldMsg) {
		fields = append(fields, msg.FieldMsg)
	}
	if m.FieldCleared(msg.FieldBatchNo) {
		fields = append(fields, msg.FieldBatchNo)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MsgMutation) 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 *MsgMutation) ClearField(name string) error {
	switch name {
	case msg.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case msg.FieldStatus:
		m.ClearStatus()
		return nil
	case msg.FieldFromwxid:
		m.ClearFromwxid()
		return nil
	case msg.FieldToid:
		m.ClearToid()
		return nil
	case msg.FieldMsgtype:
		m.ClearMsgtype()
		return nil
	case msg.FieldMsg:
		m.ClearMsg()
		return nil
	case msg.FieldBatchNo:
		m.ClearBatchNo()
		return nil
	}
	return fmt.Errorf("unknown Msg 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 *MsgMutation) ResetField(name string) error {
	switch name {
	case msg.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case msg.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case msg.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case msg.FieldStatus:
		m.ResetStatus()
		return nil
	case msg.FieldFromwxid:
		m.ResetFromwxid()
		return nil
	case msg.FieldToid:
		m.ResetToid()
		return nil
	case msg.FieldMsgtype:
		m.ResetMsgtype()
		return nil
	case msg.FieldMsg:
		m.ResetMsg()
		return nil
	case msg.FieldBatchNo:
		m.ResetBatchNo()
		return nil
	}
	return fmt.Errorf("unknown Msg field %s", name)
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *MsgMutation) 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 *MsgMutation) 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 *MsgMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown Msg 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 *MsgMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown Msg 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
	no_reply_unit          *string
	action_message         *[]custom_types.Action
	appendaction_message   []custom_types.Action
	action_label_add       *[]uint64
	appendaction_label_add []uint64
	action_label_del       *[]uint64
	appendaction_label_del []uint64
	action_forward         **custom_types.ActionForward
	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
}

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

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

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

// ResetNoReplyUnit resets all changes to the "no_reply_unit" field.
func (m *SopNodeMutation) ResetNoReplyUnit() {
	m.no_reply_unit = 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)
}

// SetActionLabelAdd sets the "action_label_add" field.
func (m *SopNodeMutation) SetActionLabelAdd(u []uint64) {
	m.action_label_add = &u
	m.appendaction_label_add = nil
}

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

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

// AppendActionLabelAdd adds u to the "action_label_add" field.
func (m *SopNodeMutation) AppendActionLabelAdd(u []uint64) {
	m.appendaction_label_add = append(m.appendaction_label_add, u...)
}

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

// ClearActionLabelAdd clears the value of the "action_label_add" field.
func (m *SopNodeMutation) ClearActionLabelAdd() {
	m.action_label_add = nil
	m.appendaction_label_add = nil
	m.clearedFields[sopnode.FieldActionLabelAdd] = struct{}{}
}

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

// ResetActionLabelAdd resets all changes to the "action_label_add" field.
func (m *SopNodeMutation) ResetActionLabelAdd() {
	m.action_label_add = nil
	m.appendaction_label_add = nil
	delete(m.clearedFields, sopnode.FieldActionLabelAdd)
}

// SetActionLabelDel sets the "action_label_del" field.
func (m *SopNodeMutation) SetActionLabelDel(u []uint64) {
	m.action_label_del = &u
	m.appendaction_label_del = nil
}

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

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

// AppendActionLabelDel adds u to the "action_label_del" field.
func (m *SopNodeMutation) AppendActionLabelDel(u []uint64) {
	m.appendaction_label_del = append(m.appendaction_label_del, u...)
}

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

// ClearActionLabelDel clears the value of the "action_label_del" field.
func (m *SopNodeMutation) ClearActionLabelDel() {
	m.action_label_del = nil
	m.appendaction_label_del = nil
	m.clearedFields[sopnode.FieldActionLabelDel] = struct{}{}
}

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

// ResetActionLabelDel resets all changes to the "action_label_del" field.
func (m *SopNodeMutation) ResetActionLabelDel() {
	m.action_label_del = nil
	m.appendaction_label_del = nil
	delete(m.clearedFields, sopnode.FieldActionLabelDel)
}

// SetActionForward sets the "action_forward" field.
func (m *SopNodeMutation) SetActionForward(ctf *custom_types.ActionForward) {
	m.action_forward = &ctf
}

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

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

// ClearActionForward clears the value of the "action_forward" field.
func (m *SopNodeMutation) ClearActionForward() {
	m.action_forward = nil
	m.clearedFields[sopnode.FieldActionForward] = struct{}{}
}

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

// ResetActionForward resets all changes to the "action_forward" field.
func (m *SopNodeMutation) ResetActionForward() {
	m.action_forward = nil
	delete(m.clearedFields, sopnode.FieldActionForward)
}

// 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, 15)
	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.no_reply_unit != nil {
		fields = append(fields, sopnode.FieldNoReplyUnit)
	}
	if m.action_message != nil {
		fields = append(fields, sopnode.FieldActionMessage)
	}
	if m.action_label_add != nil {
		fields = append(fields, sopnode.FieldActionLabelAdd)
	}
	if m.action_label_del != nil {
		fields = append(fields, sopnode.FieldActionLabelDel)
	}
	if m.action_forward != nil {
		fields = append(fields, sopnode.FieldActionForward)
	}
	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.FieldNoReplyUnit:
		return m.NoReplyUnit()
	case sopnode.FieldActionMessage:
		return m.ActionMessage()
	case sopnode.FieldActionLabelAdd:
		return m.ActionLabelAdd()
	case sopnode.FieldActionLabelDel:
		return m.ActionLabelDel()
	case sopnode.FieldActionForward:
		return m.ActionForward()
	}
	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.FieldNoReplyUnit:
		return m.OldNoReplyUnit(ctx)
	case sopnode.FieldActionMessage:
		return m.OldActionMessage(ctx)
	case sopnode.FieldActionLabelAdd:
		return m.OldActionLabelAdd(ctx)
	case sopnode.FieldActionLabelDel:
		return m.OldActionLabelDel(ctx)
	case sopnode.FieldActionForward:
		return m.OldActionForward(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.FieldNoReplyUnit:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNoReplyUnit(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.FieldActionLabelAdd:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelAdd(v)
		return nil
	case sopnode.FieldActionLabelDel:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelDel(v)
		return nil
	case sopnode.FieldActionForward:
		v, ok := value.(*custom_types.ActionForward)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionForward(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.FieldActionLabelAdd) {
		fields = append(fields, sopnode.FieldActionLabelAdd)
	}
	if m.FieldCleared(sopnode.FieldActionLabelDel) {
		fields = append(fields, sopnode.FieldActionLabelDel)
	}
	if m.FieldCleared(sopnode.FieldActionForward) {
		fields = append(fields, sopnode.FieldActionForward)
	}
	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.FieldActionLabelAdd:
		m.ClearActionLabelAdd()
		return nil
	case sopnode.FieldActionLabelDel:
		m.ClearActionLabelDel()
		return nil
	case sopnode.FieldActionForward:
		m.ClearActionForward()
		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.FieldNoReplyUnit:
		m.ResetNoReplyUnit()
		return nil
	case sopnode.FieldActionMessage:
		m.ResetActionMessage()
		return nil
	case sopnode.FieldActionLabelAdd:
		m.ResetActionLabelAdd()
		return nil
	case sopnode.FieldActionLabelDel:
		m.ResetActionLabelDel()
		return nil
	case sopnode.FieldActionForward:
		m.ResetActionForward()
		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_add       *[]uint64
	appendaction_label_add []uint64
	action_label_del       *[]uint64
	appendaction_label_del []uint64
	action_forward         **custom_types.ActionForward
	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)
}

// SetActionLabelAdd sets the "action_label_add" field.
func (m *SopStageMutation) SetActionLabelAdd(u []uint64) {
	m.action_label_add = &u
	m.appendaction_label_add = nil
}

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

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

// AppendActionLabelAdd adds u to the "action_label_add" field.
func (m *SopStageMutation) AppendActionLabelAdd(u []uint64) {
	m.appendaction_label_add = append(m.appendaction_label_add, u...)
}

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

// ClearActionLabelAdd clears the value of the "action_label_add" field.
func (m *SopStageMutation) ClearActionLabelAdd() {
	m.action_label_add = nil
	m.appendaction_label_add = nil
	m.clearedFields[sopstage.FieldActionLabelAdd] = struct{}{}
}

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

// ResetActionLabelAdd resets all changes to the "action_label_add" field.
func (m *SopStageMutation) ResetActionLabelAdd() {
	m.action_label_add = nil
	m.appendaction_label_add = nil
	delete(m.clearedFields, sopstage.FieldActionLabelAdd)
}

// SetActionLabelDel sets the "action_label_del" field.
func (m *SopStageMutation) SetActionLabelDel(u []uint64) {
	m.action_label_del = &u
	m.appendaction_label_del = nil
}

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

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

// AppendActionLabelDel adds u to the "action_label_del" field.
func (m *SopStageMutation) AppendActionLabelDel(u []uint64) {
	m.appendaction_label_del = append(m.appendaction_label_del, u...)
}

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

// ClearActionLabelDel clears the value of the "action_label_del" field.
func (m *SopStageMutation) ClearActionLabelDel() {
	m.action_label_del = nil
	m.appendaction_label_del = nil
	m.clearedFields[sopstage.FieldActionLabelDel] = struct{}{}
}

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

// ResetActionLabelDel resets all changes to the "action_label_del" field.
func (m *SopStageMutation) ResetActionLabelDel() {
	m.action_label_del = nil
	m.appendaction_label_del = nil
	delete(m.clearedFields, sopstage.FieldActionLabelDel)
}

// SetActionForward sets the "action_forward" field.
func (m *SopStageMutation) SetActionForward(ctf *custom_types.ActionForward) {
	m.action_forward = &ctf
}

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

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

// ClearActionForward clears the value of the "action_forward" field.
func (m *SopStageMutation) ClearActionForward() {
	m.action_forward = nil
	m.clearedFields[sopstage.FieldActionForward] = struct{}{}
}

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

// ResetActionForward resets all changes to the "action_forward" field.
func (m *SopStageMutation) ResetActionForward() {
	m.action_forward = nil
	delete(m.clearedFields, sopstage.FieldActionForward)
}

// 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, 14)
	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_add != nil {
		fields = append(fields, sopstage.FieldActionLabelAdd)
	}
	if m.action_label_del != nil {
		fields = append(fields, sopstage.FieldActionLabelDel)
	}
	if m.action_forward != nil {
		fields = append(fields, sopstage.FieldActionForward)
	}
	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.FieldActionLabelAdd:
		return m.ActionLabelAdd()
	case sopstage.FieldActionLabelDel:
		return m.ActionLabelDel()
	case sopstage.FieldActionForward:
		return m.ActionForward()
	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.FieldActionLabelAdd:
		return m.OldActionLabelAdd(ctx)
	case sopstage.FieldActionLabelDel:
		return m.OldActionLabelDel(ctx)
	case sopstage.FieldActionForward:
		return m.OldActionForward(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.FieldActionLabelAdd:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelAdd(v)
		return nil
	case sopstage.FieldActionLabelDel:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelDel(v)
		return nil
	case sopstage.FieldActionForward:
		v, ok := value.(*custom_types.ActionForward)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionForward(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.FieldActionLabelAdd) {
		fields = append(fields, sopstage.FieldActionLabelAdd)
	}
	if m.FieldCleared(sopstage.FieldActionLabelDel) {
		fields = append(fields, sopstage.FieldActionLabelDel)
	}
	if m.FieldCleared(sopstage.FieldActionForward) {
		fields = append(fields, sopstage.FieldActionForward)
	}
	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.FieldActionLabelAdd:
		m.ClearActionLabelAdd()
		return nil
	case sopstage.FieldActionLabelDel:
		m.ClearActionLabelDel()
		return nil
	case sopstage.FieldActionForward:
		m.ClearActionForward()
		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.FieldActionLabelAdd:
		m.ResetActionLabelAdd()
		return nil
	case sopstage.FieldActionLabelDel:
		m.ResetActionLabelDel()
		return nil
	case sopstage.FieldActionForward:
		m.ResetActionForward()
		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
	organization_id     *uint64
	addorganization_id  *int64
	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)
}

// SetOrganizationID sets the "organization_id" field.
func (m *SopTaskMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *SopTaskMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[soptask.FieldOrganizationID] = struct{}{}
}

// OrganizationIDCleared returns if the "organization_id" field was cleared in this mutation.
func (m *SopTaskMutation) OrganizationIDCleared() bool {
	_, ok := m.clearedFields[soptask.FieldOrganizationID]
	return ok
}

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *SopTaskMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, soptask.FieldOrganizationID)
}

// 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, 11)
	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)
	}
	if m.organization_id != nil {
		fields = append(fields, soptask.FieldOrganizationID)
	}
	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()
	case soptask.FieldOrganizationID:
		return m.OrganizationID()
	}
	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)
	case soptask.FieldOrganizationID:
		return m.OldOrganizationID(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
	case soptask.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, soptask.FieldOrganizationID)
	}
	return fields
}

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

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case soptask.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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)
	}
	if m.FieldCleared(soptask.FieldOrganizationID) {
		fields = append(fields, soptask.FieldOrganizationID)
	}
	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
	case soptask.FieldOrganizationID:
		m.ClearOrganizationID()
		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
	case soptask.FieldOrganizationID:
		m.ResetOrganizationID()
		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)
}

// TokenMutation represents an operation that mutates the Token nodes in the graph.
type TokenMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	expire_at     *time.Time
	token         *string
	mac           *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Token, error)
	predicates    []predicate.Token
}

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

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

// newTokenMutation creates new mutation for the Token entity.
func newTokenMutation(c config, op Op, opts ...tokenOption) *TokenMutation {
	m := &TokenMutation{
		config:        c,
		op:            op,
		typ:           TypeToken,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withToken sets the old Token of the mutation.
func withToken(node *Token) tokenOption {
	return func(m *TokenMutation) {
		m.oldValue = func(context.Context) (*Token, 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 TokenMutation) 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 TokenMutation) 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 Token entities.
func (m *TokenMutation) 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 *TokenMutation) 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 *TokenMutation) 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().Token.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 *TokenMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *TokenMutation) 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 Token entity.
// If the Token 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 *TokenMutation) 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 *TokenMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[token.FieldDeletedAt] = struct{}{}
}

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

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

// SetExpireAt sets the "expire_at" field.
func (m *TokenMutation) SetExpireAt(t time.Time) {
	m.expire_at = &t
}

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

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

// ClearExpireAt clears the value of the "expire_at" field.
func (m *TokenMutation) ClearExpireAt() {
	m.expire_at = nil
	m.clearedFields[token.FieldExpireAt] = struct{}{}
}

// ExpireAtCleared returns if the "expire_at" field was cleared in this mutation.
func (m *TokenMutation) ExpireAtCleared() bool {
	_, ok := m.clearedFields[token.FieldExpireAt]
	return ok
}

// ResetExpireAt resets all changes to the "expire_at" field.
func (m *TokenMutation) ResetExpireAt() {
	m.expire_at = nil
	delete(m.clearedFields, token.FieldExpireAt)
}

// SetToken sets the "token" field.
func (m *TokenMutation) SetToken(s string) {
	m.token = &s
}

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

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

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

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

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

// SetMAC sets the "mac" field.
func (m *TokenMutation) SetMAC(s string) {
	m.mac = &s
}

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

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

// ResetMAC resets all changes to the "mac" field.
func (m *TokenMutation) ResetMAC() {
	m.mac = nil
}

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

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

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

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

// Type returns the node type of this mutation (Token).
func (m *TokenMutation) 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 *TokenMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.created_at != nil {
		fields = append(fields, token.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, token.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, token.FieldDeletedAt)
	}
	if m.expire_at != nil {
		fields = append(fields, token.FieldExpireAt)
	}
	if m.token != nil {
		fields = append(fields, token.FieldToken)
	}
	if m.mac != nil {
		fields = append(fields, token.FieldMAC)
	}
	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 *TokenMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case token.FieldCreatedAt:
		return m.CreatedAt()
	case token.FieldUpdatedAt:
		return m.UpdatedAt()
	case token.FieldDeletedAt:
		return m.DeletedAt()
	case token.FieldExpireAt:
		return m.ExpireAt()
	case token.FieldToken:
		return m.Token()
	case token.FieldMAC:
		return m.MAC()
	}
	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 *TokenMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case token.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case token.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case token.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case token.FieldExpireAt:
		return m.OldExpireAt(ctx)
	case token.FieldToken:
		return m.OldToken(ctx)
	case token.FieldMAC:
		return m.OldMAC(ctx)
	}
	return nil, fmt.Errorf("unknown Token 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 *TokenMutation) SetField(name string, value ent.Value) error {
	switch name {
	case token.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 token.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 token.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 token.FieldExpireAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExpireAt(v)
		return nil
	case token.FieldToken:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToken(v)
		return nil
	case token.FieldMAC:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMAC(v)
		return nil
	}
	return fmt.Errorf("unknown Token field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *TokenMutation) 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 *TokenMutation) ClearField(name string) error {
	switch name {
	case token.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case token.FieldExpireAt:
		m.ClearExpireAt()
		return nil
	case token.FieldToken:
		m.ClearToken()
		return nil
	}
	return fmt.Errorf("unknown Token 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 *TokenMutation) ResetField(name string) error {
	switch name {
	case token.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case token.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case token.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case token.FieldExpireAt:
		m.ResetExpireAt()
		return nil
	case token.FieldToken:
		m.ResetToken()
		return nil
	case token.FieldMAC:
		m.ResetMAC()
		return nil
	}
	return fmt.Errorf("unknown Token field %s", name)
}

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

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

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

// TutorialMutation represents an operation that mutates the Tutorial nodes in the graph.
type TutorialMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	index              *int
	addindex           *int
	title              *string
	content            *string
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	employee           *uint64
	clearedemployee    bool
	done               bool
	oldValue           func(context.Context) (*Tutorial, error)
	predicates         []predicate.Tutorial
}

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

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

// newTutorialMutation creates new mutation for the Tutorial entity.
func newTutorialMutation(c config, op Op, opts ...tutorialOption) *TutorialMutation {
	m := &TutorialMutation{
		config:        c,
		op:            op,
		typ:           TypeTutorial,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withTutorial sets the old Tutorial of the mutation.
func withTutorial(node *Tutorial) tutorialOption {
	return func(m *TutorialMutation) {
		m.oldValue = func(context.Context) (*Tutorial, 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 TutorialMutation) 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 TutorialMutation) 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 Tutorial entities.
func (m *TutorialMutation) 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 *TutorialMutation) 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 *TutorialMutation) 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().Tutorial.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 *TutorialMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *TutorialMutation) 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 Tutorial entity.
// If the Tutorial 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 *TutorialMutation) 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 *TutorialMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[tutorial.FieldDeletedAt] = struct{}{}
}

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

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

// SetEmployeeID sets the "employee_id" field.
func (m *TutorialMutation) SetEmployeeID(u uint64) {
	m.employee = &u
}

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

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

// ResetEmployeeID resets all changes to the "employee_id" field.
func (m *TutorialMutation) ResetEmployeeID() {
	m.employee = nil
}

// SetIndex sets the "index" field.
func (m *TutorialMutation) SetIndex(i int) {
	m.index = &i
	m.addindex = nil
}

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

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

// AddIndex adds i to the "index" field.
func (m *TutorialMutation) AddIndex(i int) {
	if m.addindex != nil {
		*m.addindex += i
	} else {
		m.addindex = &i
	}
}

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

// ResetIndex resets all changes to the "index" field.
func (m *TutorialMutation) ResetIndex() {
	m.index = nil
	m.addindex = nil
}

// SetTitle sets the "title" field.
func (m *TutorialMutation) SetTitle(s string) {
	m.title = &s
}

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

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

// ResetTitle resets all changes to the "title" field.
func (m *TutorialMutation) ResetTitle() {
	m.title = nil
}

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

// Content returns the value of the "content" field in the mutation.
func (m *TutorialMutation) 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 Tutorial entity.
// If the Tutorial 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 *TutorialMutation) 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 *TutorialMutation) ResetContent() {
	m.content = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *TutorialMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

// ClearEmployee clears the "employee" edge to the Employee entity.
func (m *TutorialMutation) ClearEmployee() {
	m.clearedemployee = true
	m.clearedFields[tutorial.FieldEmployeeID] = struct{}{}
}

// EmployeeCleared reports if the "employee" edge to the Employee entity was cleared.
func (m *TutorialMutation) EmployeeCleared() bool {
	return m.clearedemployee
}

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

// ResetEmployee resets all changes to the "employee" edge.
func (m *TutorialMutation) ResetEmployee() {
	m.employee = nil
	m.clearedemployee = false
}

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

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

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

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

// Type returns the node type of this mutation (Tutorial).
func (m *TutorialMutation) 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 *TutorialMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, tutorial.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, tutorial.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, tutorial.FieldDeletedAt)
	}
	if m.employee != nil {
		fields = append(fields, tutorial.FieldEmployeeID)
	}
	if m.index != nil {
		fields = append(fields, tutorial.FieldIndex)
	}
	if m.title != nil {
		fields = append(fields, tutorial.FieldTitle)
	}
	if m.content != nil {
		fields = append(fields, tutorial.FieldContent)
	}
	if m.organization_id != nil {
		fields = append(fields, tutorial.FieldOrganizationID)
	}
	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 *TutorialMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case tutorial.FieldCreatedAt:
		return m.CreatedAt()
	case tutorial.FieldUpdatedAt:
		return m.UpdatedAt()
	case tutorial.FieldDeletedAt:
		return m.DeletedAt()
	case tutorial.FieldEmployeeID:
		return m.EmployeeID()
	case tutorial.FieldIndex:
		return m.Index()
	case tutorial.FieldTitle:
		return m.Title()
	case tutorial.FieldContent:
		return m.Content()
	case tutorial.FieldOrganizationID:
		return m.OrganizationID()
	}
	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 *TutorialMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case tutorial.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case tutorial.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case tutorial.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case tutorial.FieldEmployeeID:
		return m.OldEmployeeID(ctx)
	case tutorial.FieldIndex:
		return m.OldIndex(ctx)
	case tutorial.FieldTitle:
		return m.OldTitle(ctx)
	case tutorial.FieldContent:
		return m.OldContent(ctx)
	case tutorial.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown Tutorial 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 *TutorialMutation) SetField(name string, value ent.Value) error {
	switch name {
	case tutorial.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 tutorial.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 tutorial.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 tutorial.FieldEmployeeID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmployeeID(v)
		return nil
	case tutorial.FieldIndex:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIndex(v)
		return nil
	case tutorial.FieldTitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTitle(v)
		return nil
	case tutorial.FieldContent:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContent(v)
		return nil
	case tutorial.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown Tutorial field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *TutorialMutation) AddedFields() []string {
	var fields []string
	if m.addindex != nil {
		fields = append(fields, tutorial.FieldIndex)
	}
	if m.addorganization_id != nil {
		fields = append(fields, tutorial.FieldOrganizationID)
	}
	return fields
}

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

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *TutorialMutation) AddField(name string, value ent.Value) error {
	switch name {
	case tutorial.FieldIndex:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddIndex(v)
		return nil
	case tutorial.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown Tutorial numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *TutorialMutation) 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 *TutorialMutation) ClearField(name string) error {
	switch name {
	case tutorial.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Tutorial 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 *TutorialMutation) ResetField(name string) error {
	switch name {
	case tutorial.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case tutorial.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case tutorial.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case tutorial.FieldEmployeeID:
		m.ResetEmployeeID()
		return nil
	case tutorial.FieldIndex:
		m.ResetIndex()
		return nil
	case tutorial.FieldTitle:
		m.ResetTitle()
		return nil
	case tutorial.FieldContent:
		m.ResetContent()
		return nil
	case tutorial.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown Tutorial field %s", name)
}

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *TutorialMutation) EdgeCleared(name string) bool {
	switch name {
	case tutorial.EdgeEmployee:
		return m.clearedemployee
	}
	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 *TutorialMutation) ClearEdge(name string) error {
	switch name {
	case tutorial.EdgeEmployee:
		m.ClearEmployee()
		return nil
	}
	return fmt.Errorf("unknown Tutorial 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 *TutorialMutation) ResetEdge(name string) error {
	switch name {
	case tutorial.EdgeEmployee:
		m.ResetEmployee()
		return nil
	}
	return fmt.Errorf("unknown Tutorial edge %s", name)
}

// WorkExperienceMutation represents an operation that mutates the WorkExperience nodes in the graph.
type WorkExperienceMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	start_date         *time.Time
	end_date           *time.Time
	company            *string
	experience         *string
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	employee           *uint64
	clearedemployee    bool
	done               bool
	oldValue           func(context.Context) (*WorkExperience, error)
	predicates         []predicate.WorkExperience
}

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

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

// newWorkExperienceMutation creates new mutation for the WorkExperience entity.
func newWorkExperienceMutation(c config, op Op, opts ...workexperienceOption) *WorkExperienceMutation {
	m := &WorkExperienceMutation{
		config:        c,
		op:            op,
		typ:           TypeWorkExperience,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWorkExperience sets the old WorkExperience of the mutation.
func withWorkExperience(node *WorkExperience) workexperienceOption {
	return func(m *WorkExperienceMutation) {
		m.oldValue = func(context.Context) (*WorkExperience, 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 WorkExperienceMutation) 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 WorkExperienceMutation) 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 WorkExperience entities.
func (m *WorkExperienceMutation) 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 *WorkExperienceMutation) 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 *WorkExperienceMutation) 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().WorkExperience.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 *WorkExperienceMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WorkExperienceMutation) 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 WorkExperience entity.
// If the WorkExperience 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 *WorkExperienceMutation) 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 *WorkExperienceMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[workexperience.FieldDeletedAt] = struct{}{}
}

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

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

// SetEmployeeID sets the "employee_id" field.
func (m *WorkExperienceMutation) SetEmployeeID(u uint64) {
	m.employee = &u
}

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

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

// ResetEmployeeID resets all changes to the "employee_id" field.
func (m *WorkExperienceMutation) ResetEmployeeID() {
	m.employee = nil
}

// SetStartDate sets the "start_date" field.
func (m *WorkExperienceMutation) SetStartDate(t time.Time) {
	m.start_date = &t
}

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

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

// ResetStartDate resets all changes to the "start_date" field.
func (m *WorkExperienceMutation) ResetStartDate() {
	m.start_date = nil
}

// SetEndDate sets the "end_date" field.
func (m *WorkExperienceMutation) SetEndDate(t time.Time) {
	m.end_date = &t
}

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

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

// ResetEndDate resets all changes to the "end_date" field.
func (m *WorkExperienceMutation) ResetEndDate() {
	m.end_date = nil
}

// SetCompany sets the "company" field.
func (m *WorkExperienceMutation) SetCompany(s string) {
	m.company = &s
}

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

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

// ResetCompany resets all changes to the "company" field.
func (m *WorkExperienceMutation) ResetCompany() {
	m.company = nil
}

// SetExperience sets the "experience" field.
func (m *WorkExperienceMutation) SetExperience(s string) {
	m.experience = &s
}

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

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

// ResetExperience resets all changes to the "experience" field.
func (m *WorkExperienceMutation) ResetExperience() {
	m.experience = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *WorkExperienceMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

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

// ClearEmployee clears the "employee" edge to the Employee entity.
func (m *WorkExperienceMutation) ClearEmployee() {
	m.clearedemployee = true
	m.clearedFields[workexperience.FieldEmployeeID] = struct{}{}
}

// EmployeeCleared reports if the "employee" edge to the Employee entity was cleared.
func (m *WorkExperienceMutation) EmployeeCleared() bool {
	return m.clearedemployee
}

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

// ResetEmployee resets all changes to the "employee" edge.
func (m *WorkExperienceMutation) ResetEmployee() {
	m.employee = nil
	m.clearedemployee = false
}

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

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

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

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

// Type returns the node type of this mutation (WorkExperience).
func (m *WorkExperienceMutation) 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 *WorkExperienceMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, workexperience.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, workexperience.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, workexperience.FieldDeletedAt)
	}
	if m.employee != nil {
		fields = append(fields, workexperience.FieldEmployeeID)
	}
	if m.start_date != nil {
		fields = append(fields, workexperience.FieldStartDate)
	}
	if m.end_date != nil {
		fields = append(fields, workexperience.FieldEndDate)
	}
	if m.company != nil {
		fields = append(fields, workexperience.FieldCompany)
	}
	if m.experience != nil {
		fields = append(fields, workexperience.FieldExperience)
	}
	if m.organization_id != nil {
		fields = append(fields, workexperience.FieldOrganizationID)
	}
	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 *WorkExperienceMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case workexperience.FieldCreatedAt:
		return m.CreatedAt()
	case workexperience.FieldUpdatedAt:
		return m.UpdatedAt()
	case workexperience.FieldDeletedAt:
		return m.DeletedAt()
	case workexperience.FieldEmployeeID:
		return m.EmployeeID()
	case workexperience.FieldStartDate:
		return m.StartDate()
	case workexperience.FieldEndDate:
		return m.EndDate()
	case workexperience.FieldCompany:
		return m.Company()
	case workexperience.FieldExperience:
		return m.Experience()
	case workexperience.FieldOrganizationID:
		return m.OrganizationID()
	}
	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 *WorkExperienceMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case workexperience.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case workexperience.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case workexperience.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case workexperience.FieldEmployeeID:
		return m.OldEmployeeID(ctx)
	case workexperience.FieldStartDate:
		return m.OldStartDate(ctx)
	case workexperience.FieldEndDate:
		return m.OldEndDate(ctx)
	case workexperience.FieldCompany:
		return m.OldCompany(ctx)
	case workexperience.FieldExperience:
		return m.OldExperience(ctx)
	case workexperience.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown WorkExperience 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 *WorkExperienceMutation) SetField(name string, value ent.Value) error {
	switch name {
	case workexperience.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 workexperience.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 workexperience.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 workexperience.FieldEmployeeID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmployeeID(v)
		return nil
	case workexperience.FieldStartDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartDate(v)
		return nil
	case workexperience.FieldEndDate:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEndDate(v)
		return nil
	case workexperience.FieldCompany:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompany(v)
		return nil
	case workexperience.FieldExperience:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExperience(v)
		return nil
	case workexperience.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	}
	return fmt.Errorf("unknown WorkExperience field %s", name)
}

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

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

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WorkExperienceMutation) 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 *WorkExperienceMutation) ClearField(name string) error {
	switch name {
	case workexperience.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown WorkExperience 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 *WorkExperienceMutation) ResetField(name string) error {
	switch name {
	case workexperience.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case workexperience.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case workexperience.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case workexperience.FieldEmployeeID:
		m.ResetEmployeeID()
		return nil
	case workexperience.FieldStartDate:
		m.ResetStartDate()
		return nil
	case workexperience.FieldEndDate:
		m.ResetEndDate()
		return nil
	case workexperience.FieldCompany:
		m.ResetCompany()
		return nil
	case workexperience.FieldExperience:
		m.ResetExperience()
		return nil
	case workexperience.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown WorkExperience field %s", name)
}

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WorkExperienceMutation) EdgeCleared(name string) bool {
	switch name {
	case workexperience.EdgeEmployee:
		return m.clearedemployee
	}
	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 *WorkExperienceMutation) ClearEdge(name string) error {
	switch name {
	case workexperience.EdgeEmployee:
		m.ClearEmployee()
		return nil
	}
	return fmt.Errorf("unknown WorkExperience 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 *WorkExperienceMutation) ResetEdge(name string) error {
	switch name {
	case workexperience.EdgeEmployee:
		m.ResetEmployee()
		return nil
	}
	return fmt.Errorf("unknown WorkExperience 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
	organization_id        *uint64
	addorganization_id     *int64
	api_base               *string
	api_key                *string
	allow_list             *[]string
	appendallow_list       []string
	group_allow_list       *[]string
	appendgroup_allow_list []string
	block_list             *[]string
	appendblock_list       []string
	group_block_list       *[]string
	appendgroup_block_list []string
	clearedFields          map[string]struct{}
	server                 *uint64
	clearedserver          bool
	agent                  *uint64
	clearedagent           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
}

// SetOrganizationID sets the "organization_id" field.
func (m *WxMutation) SetOrganizationID(u uint64) {
	m.organization_id = &u
	m.addorganization_id = nil
}

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

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

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

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

// ClearOrganizationID clears the value of the "organization_id" field.
func (m *WxMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[wx.FieldOrganizationID] = struct{}{}
}

// OrganizationIDCleared returns if the "organization_id" field was cleared in this mutation.
func (m *WxMutation) OrganizationIDCleared() bool {
	_, ok := m.clearedFields[wx.FieldOrganizationID]
	return ok
}

// ResetOrganizationID resets all changes to the "organization_id" field.
func (m *WxMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	delete(m.clearedFields, wx.FieldOrganizationID)
}

// SetAgentID sets the "agent_id" field.
func (m *WxMutation) SetAgentID(u uint64) {
	m.agent = &u
}

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

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

// ResetAgentID resets all changes to the "agent_id" field.
func (m *WxMutation) ResetAgentID() {
	m.agent = nil
}

// SetAPIBase sets the "api_base" field.
func (m *WxMutation) SetAPIBase(s string) {
	m.api_base = &s
}

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

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

// ClearAPIBase clears the value of the "api_base" field.
func (m *WxMutation) ClearAPIBase() {
	m.api_base = nil
	m.clearedFields[wx.FieldAPIBase] = struct{}{}
}

// APIBaseCleared returns if the "api_base" field was cleared in this mutation.
func (m *WxMutation) APIBaseCleared() bool {
	_, ok := m.clearedFields[wx.FieldAPIBase]
	return ok
}

// ResetAPIBase resets all changes to the "api_base" field.
func (m *WxMutation) ResetAPIBase() {
	m.api_base = nil
	delete(m.clearedFields, wx.FieldAPIBase)
}

// SetAPIKey sets the "api_key" field.
func (m *WxMutation) SetAPIKey(s string) {
	m.api_key = &s
}

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

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

// ClearAPIKey clears the value of the "api_key" field.
func (m *WxMutation) ClearAPIKey() {
	m.api_key = nil
	m.clearedFields[wx.FieldAPIKey] = struct{}{}
}

// APIKeyCleared returns if the "api_key" field was cleared in this mutation.
func (m *WxMutation) APIKeyCleared() bool {
	_, ok := m.clearedFields[wx.FieldAPIKey]
	return ok
}

// ResetAPIKey resets all changes to the "api_key" field.
func (m *WxMutation) ResetAPIKey() {
	m.api_key = nil
	delete(m.clearedFields, wx.FieldAPIKey)
}

// SetAllowList sets the "allow_list" field.
func (m *WxMutation) SetAllowList(s []string) {
	m.allow_list = &s
	m.appendallow_list = nil
}

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

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

// AppendAllowList adds s to the "allow_list" field.
func (m *WxMutation) AppendAllowList(s []string) {
	m.appendallow_list = append(m.appendallow_list, s...)
}

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

// ResetAllowList resets all changes to the "allow_list" field.
func (m *WxMutation) ResetAllowList() {
	m.allow_list = nil
	m.appendallow_list = nil
}

// SetGroupAllowList sets the "group_allow_list" field.
func (m *WxMutation) SetGroupAllowList(s []string) {
	m.group_allow_list = &s
	m.appendgroup_allow_list = nil
}

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

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

// AppendGroupAllowList adds s to the "group_allow_list" field.
func (m *WxMutation) AppendGroupAllowList(s []string) {
	m.appendgroup_allow_list = append(m.appendgroup_allow_list, s...)
}

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

// ResetGroupAllowList resets all changes to the "group_allow_list" field.
func (m *WxMutation) ResetGroupAllowList() {
	m.group_allow_list = nil
	m.appendgroup_allow_list = nil
}

// SetBlockList sets the "block_list" field.
func (m *WxMutation) SetBlockList(s []string) {
	m.block_list = &s
	m.appendblock_list = nil
}

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

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

// AppendBlockList adds s to the "block_list" field.
func (m *WxMutation) AppendBlockList(s []string) {
	m.appendblock_list = append(m.appendblock_list, s...)
}

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

// ResetBlockList resets all changes to the "block_list" field.
func (m *WxMutation) ResetBlockList() {
	m.block_list = nil
	m.appendblock_list = nil
}

// SetGroupBlockList sets the "group_block_list" field.
func (m *WxMutation) SetGroupBlockList(s []string) {
	m.group_block_list = &s
	m.appendgroup_block_list = nil
}

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

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

// AppendGroupBlockList adds s to the "group_block_list" field.
func (m *WxMutation) AppendGroupBlockList(s []string) {
	m.appendgroup_block_list = append(m.appendgroup_block_list, s...)
}

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

// ResetGroupBlockList resets all changes to the "group_block_list" field.
func (m *WxMutation) ResetGroupBlockList() {
	m.group_block_list = nil
	m.appendgroup_block_list = 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
}

// ClearAgent clears the "agent" edge to the Agent entity.
func (m *WxMutation) ClearAgent() {
	m.clearedagent = true
	m.clearedFields[wx.FieldAgentID] = struct{}{}
}

// AgentCleared reports if the "agent" edge to the Agent entity was cleared.
func (m *WxMutation) AgentCleared() bool {
	return m.clearedagent
}

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

// ResetAgent resets all changes to the "agent" edge.
func (m *WxMutation) ResetAgent() {
	m.agent = nil
	m.clearedagent = 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, 21)
	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)
	}
	if m.organization_id != nil {
		fields = append(fields, wx.FieldOrganizationID)
	}
	if m.agent != nil {
		fields = append(fields, wx.FieldAgentID)
	}
	if m.api_base != nil {
		fields = append(fields, wx.FieldAPIBase)
	}
	if m.api_key != nil {
		fields = append(fields, wx.FieldAPIKey)
	}
	if m.allow_list != nil {
		fields = append(fields, wx.FieldAllowList)
	}
	if m.group_allow_list != nil {
		fields = append(fields, wx.FieldGroupAllowList)
	}
	if m.block_list != nil {
		fields = append(fields, wx.FieldBlockList)
	}
	if m.group_block_list != nil {
		fields = append(fields, wx.FieldGroupBlockList)
	}
	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()
	case wx.FieldOrganizationID:
		return m.OrganizationID()
	case wx.FieldAgentID:
		return m.AgentID()
	case wx.FieldAPIBase:
		return m.APIBase()
	case wx.FieldAPIKey:
		return m.APIKey()
	case wx.FieldAllowList:
		return m.AllowList()
	case wx.FieldGroupAllowList:
		return m.GroupAllowList()
	case wx.FieldBlockList:
		return m.BlockList()
	case wx.FieldGroupBlockList:
		return m.GroupBlockList()
	}
	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)
	case wx.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case wx.FieldAgentID:
		return m.OldAgentID(ctx)
	case wx.FieldAPIBase:
		return m.OldAPIBase(ctx)
	case wx.FieldAPIKey:
		return m.OldAPIKey(ctx)
	case wx.FieldAllowList:
		return m.OldAllowList(ctx)
	case wx.FieldGroupAllowList:
		return m.OldGroupAllowList(ctx)
	case wx.FieldBlockList:
		return m.OldBlockList(ctx)
	case wx.FieldGroupBlockList:
		return m.OldGroupBlockList(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
	case wx.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case wx.FieldAgentID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAgentID(v)
		return nil
	case wx.FieldAPIBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIBase(v)
		return nil
	case wx.FieldAPIKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIKey(v)
		return nil
	case wx.FieldAllowList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAllowList(v)
		return nil
	case wx.FieldGroupAllowList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGroupAllowList(v)
		return nil
	case wx.FieldBlockList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBlockList(v)
		return nil
	case wx.FieldGroupBlockList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGroupBlockList(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)
	}
	if m.addorganization_id != nil {
		fields = append(fields, wx.FieldOrganizationID)
	}
	return fields
}

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

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *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
	case wx.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(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)
	}
	if m.FieldCleared(wx.FieldOrganizationID) {
		fields = append(fields, wx.FieldOrganizationID)
	}
	if m.FieldCleared(wx.FieldAPIBase) {
		fields = append(fields, wx.FieldAPIBase)
	}
	if m.FieldCleared(wx.FieldAPIKey) {
		fields = append(fields, wx.FieldAPIKey)
	}
	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
	case wx.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	case wx.FieldAPIBase:
		m.ClearAPIBase()
		return nil
	case wx.FieldAPIKey:
		m.ClearAPIKey()
		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
	case wx.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case wx.FieldAgentID:
		m.ResetAgentID()
		return nil
	case wx.FieldAPIBase:
		m.ResetAPIBase()
		return nil
	case wx.FieldAPIKey:
		m.ResetAPIKey()
		return nil
	case wx.FieldAllowList:
		m.ResetAllowList()
		return nil
	case wx.FieldGroupAllowList:
		m.ResetGroupAllowList()
		return nil
	case wx.FieldBlockList:
		m.ResetBlockList()
		return nil
	case wx.FieldGroupBlockList:
		m.ResetGroupBlockList()
		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, 2)
	if m.server != nil {
		edges = append(edges, wx.EdgeServer)
	}
	if m.agent != nil {
		edges = append(edges, wx.EdgeAgent)
	}
	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}
		}
	case wx.EdgeAgent:
		if id := m.agent; 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, 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 *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, 2)
	if m.clearedserver {
		edges = append(edges, wx.EdgeServer)
	}
	if m.clearedagent {
		edges = append(edges, wx.EdgeAgent)
	}
	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
	case wx.EdgeAgent:
		return m.clearedagent
	}
	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
	case wx.EdgeAgent:
		m.ClearAgent()
		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
	case wx.EdgeAgent:
		m.ResetAgent()
		return nil
	}
	return fmt.Errorf("unknown Wx edge %s", name)
}

// WxCardMutation represents an operation that mutates the WxCard nodes in the graph.
type WxCardMutation struct {
	config
	op               Op
	typ              string
	id               *uint64
	created_at       *time.Time
	updated_at       *time.Time
	deleted_at       *time.Time
	user_id          *uint64
	adduser_id       *int64
	wx_user_id       *uint64
	addwx_user_id    *int64
	avatar           *string
	logo             *string
	name             *string
	company          *string
	address          *string
	phone            *string
	official_account *string
	wechat_account   *string
	email            *string
	api_base         *string
	api_key          *string
	ai_info          *string
	intro            *string
	clearedFields    map[string]struct{}
	done             bool
	oldValue         func(context.Context) (*WxCard, error)
	predicates       []predicate.WxCard
}

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

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

// newWxCardMutation creates new mutation for the WxCard entity.
func newWxCardMutation(c config, op Op, opts ...wxcardOption) *WxCardMutation {
	m := &WxCardMutation{
		config:        c,
		op:            op,
		typ:           TypeWxCard,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWxCard sets the old WxCard of the mutation.
func withWxCard(node *WxCard) wxcardOption {
	return func(m *WxCardMutation) {
		m.oldValue = func(context.Context) (*WxCard, 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 WxCardMutation) 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 WxCardMutation) 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 WxCard entities.
func (m *WxCardMutation) 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 *WxCardMutation) 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 *WxCardMutation) 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().WxCard.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 *WxCardMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WxCardMutation) 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 WxCard entity.
// If the WxCard 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 *WxCardMutation) 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 *WxCardMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[wxcard.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *WxCardMutation) SetUserID(u uint64) {
	m.user_id = &u
	m.adduser_id = nil
}

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

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

// AddUserID adds u to the "user_id" field.
func (m *WxCardMutation) AddUserID(u int64) {
	if m.adduser_id != nil {
		*m.adduser_id += u
	} else {
		m.adduser_id = &u
	}
}

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

// ClearUserID clears the value of the "user_id" field.
func (m *WxCardMutation) ClearUserID() {
	m.user_id = nil
	m.adduser_id = nil
	m.clearedFields[wxcard.FieldUserID] = struct{}{}
}

// UserIDCleared returns if the "user_id" field was cleared in this mutation.
func (m *WxCardMutation) UserIDCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldUserID]
	return ok
}

// ResetUserID resets all changes to the "user_id" field.
func (m *WxCardMutation) ResetUserID() {
	m.user_id = nil
	m.adduser_id = nil
	delete(m.clearedFields, wxcard.FieldUserID)
}

// SetWxUserID sets the "wx_user_id" field.
func (m *WxCardMutation) SetWxUserID(u uint64) {
	m.wx_user_id = &u
	m.addwx_user_id = nil
}

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

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

// AddWxUserID adds u to the "wx_user_id" field.
func (m *WxCardMutation) AddWxUserID(u int64) {
	if m.addwx_user_id != nil {
		*m.addwx_user_id += u
	} else {
		m.addwx_user_id = &u
	}
}

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

// ClearWxUserID clears the value of the "wx_user_id" field.
func (m *WxCardMutation) ClearWxUserID() {
	m.wx_user_id = nil
	m.addwx_user_id = nil
	m.clearedFields[wxcard.FieldWxUserID] = struct{}{}
}

// WxUserIDCleared returns if the "wx_user_id" field was cleared in this mutation.
func (m *WxCardMutation) WxUserIDCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldWxUserID]
	return ok
}

// ResetWxUserID resets all changes to the "wx_user_id" field.
func (m *WxCardMutation) ResetWxUserID() {
	m.wx_user_id = nil
	m.addwx_user_id = nil
	delete(m.clearedFields, wxcard.FieldWxUserID)
}

// SetAvatar sets the "avatar" field.
func (m *WxCardMutation) SetAvatar(s string) {
	m.avatar = &s
}

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

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

// ResetAvatar resets all changes to the "avatar" field.
func (m *WxCardMutation) ResetAvatar() {
	m.avatar = nil
}

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

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

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

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

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

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

// SetCompany sets the "company" field.
func (m *WxCardMutation) SetCompany(s string) {
	m.company = &s
}

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

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

// ResetCompany resets all changes to the "company" field.
func (m *WxCardMutation) ResetCompany() {
	m.company = nil
}

// SetAddress sets the "address" field.
func (m *WxCardMutation) SetAddress(s string) {
	m.address = &s
}

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

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

// ResetAddress resets all changes to the "address" field.
func (m *WxCardMutation) ResetAddress() {
	m.address = nil
}

// SetPhone sets the "phone" field.
func (m *WxCardMutation) SetPhone(s string) {
	m.phone = &s
}

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

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

// ResetPhone resets all changes to the "phone" field.
func (m *WxCardMutation) ResetPhone() {
	m.phone = nil
}

// SetOfficialAccount sets the "official_account" field.
func (m *WxCardMutation) SetOfficialAccount(s string) {
	m.official_account = &s
}

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

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

// ResetOfficialAccount resets all changes to the "official_account" field.
func (m *WxCardMutation) ResetOfficialAccount() {
	m.official_account = nil
}

// SetWechatAccount sets the "wechat_account" field.
func (m *WxCardMutation) SetWechatAccount(s string) {
	m.wechat_account = &s
}

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

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

// ResetWechatAccount resets all changes to the "wechat_account" field.
func (m *WxCardMutation) ResetWechatAccount() {
	m.wechat_account = nil
}

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

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

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

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

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

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

// SetAPIBase sets the "api_base" field.
func (m *WxCardMutation) SetAPIBase(s string) {
	m.api_base = &s
}

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

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

// ClearAPIBase clears the value of the "api_base" field.
func (m *WxCardMutation) ClearAPIBase() {
	m.api_base = nil
	m.clearedFields[wxcard.FieldAPIBase] = struct{}{}
}

// APIBaseCleared returns if the "api_base" field was cleared in this mutation.
func (m *WxCardMutation) APIBaseCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldAPIBase]
	return ok
}

// ResetAPIBase resets all changes to the "api_base" field.
func (m *WxCardMutation) ResetAPIBase() {
	m.api_base = nil
	delete(m.clearedFields, wxcard.FieldAPIBase)
}

// SetAPIKey sets the "api_key" field.
func (m *WxCardMutation) SetAPIKey(s string) {
	m.api_key = &s
}

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

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

// ClearAPIKey clears the value of the "api_key" field.
func (m *WxCardMutation) ClearAPIKey() {
	m.api_key = nil
	m.clearedFields[wxcard.FieldAPIKey] = struct{}{}
}

// APIKeyCleared returns if the "api_key" field was cleared in this mutation.
func (m *WxCardMutation) APIKeyCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldAPIKey]
	return ok
}

// ResetAPIKey resets all changes to the "api_key" field.
func (m *WxCardMutation) ResetAPIKey() {
	m.api_key = nil
	delete(m.clearedFields, wxcard.FieldAPIKey)
}

// SetAiInfo sets the "ai_info" field.
func (m *WxCardMutation) SetAiInfo(s string) {
	m.ai_info = &s
}

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

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

// ClearAiInfo clears the value of the "ai_info" field.
func (m *WxCardMutation) ClearAiInfo() {
	m.ai_info = nil
	m.clearedFields[wxcard.FieldAiInfo] = struct{}{}
}

// AiInfoCleared returns if the "ai_info" field was cleared in this mutation.
func (m *WxCardMutation) AiInfoCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldAiInfo]
	return ok
}

// ResetAiInfo resets all changes to the "ai_info" field.
func (m *WxCardMutation) ResetAiInfo() {
	m.ai_info = nil
	delete(m.clearedFields, wxcard.FieldAiInfo)
}

// SetIntro sets the "intro" field.
func (m *WxCardMutation) SetIntro(s string) {
	m.intro = &s
}

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

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

// ClearIntro clears the value of the "intro" field.
func (m *WxCardMutation) ClearIntro() {
	m.intro = nil
	m.clearedFields[wxcard.FieldIntro] = struct{}{}
}

// IntroCleared returns if the "intro" field was cleared in this mutation.
func (m *WxCardMutation) IntroCleared() bool {
	_, ok := m.clearedFields[wxcard.FieldIntro]
	return ok
}

// ResetIntro resets all changes to the "intro" field.
func (m *WxCardMutation) ResetIntro() {
	m.intro = nil
	delete(m.clearedFields, wxcard.FieldIntro)
}

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

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

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

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

// Type returns the node type of this mutation (WxCard).
func (m *WxCardMutation) 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 *WxCardMutation) Fields() []string {
	fields := make([]string, 0, 18)
	if m.created_at != nil {
		fields = append(fields, wxcard.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wxcard.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, wxcard.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, wxcard.FieldUserID)
	}
	if m.wx_user_id != nil {
		fields = append(fields, wxcard.FieldWxUserID)
	}
	if m.avatar != nil {
		fields = append(fields, wxcard.FieldAvatar)
	}
	if m.logo != nil {
		fields = append(fields, wxcard.FieldLogo)
	}
	if m.name != nil {
		fields = append(fields, wxcard.FieldName)
	}
	if m.company != nil {
		fields = append(fields, wxcard.FieldCompany)
	}
	if m.address != nil {
		fields = append(fields, wxcard.FieldAddress)
	}
	if m.phone != nil {
		fields = append(fields, wxcard.FieldPhone)
	}
	if m.official_account != nil {
		fields = append(fields, wxcard.FieldOfficialAccount)
	}
	if m.wechat_account != nil {
		fields = append(fields, wxcard.FieldWechatAccount)
	}
	if m.email != nil {
		fields = append(fields, wxcard.FieldEmail)
	}
	if m.api_base != nil {
		fields = append(fields, wxcard.FieldAPIBase)
	}
	if m.api_key != nil {
		fields = append(fields, wxcard.FieldAPIKey)
	}
	if m.ai_info != nil {
		fields = append(fields, wxcard.FieldAiInfo)
	}
	if m.intro != nil {
		fields = append(fields, wxcard.FieldIntro)
	}
	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 *WxCardMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wxcard.FieldCreatedAt:
		return m.CreatedAt()
	case wxcard.FieldUpdatedAt:
		return m.UpdatedAt()
	case wxcard.FieldDeletedAt:
		return m.DeletedAt()
	case wxcard.FieldUserID:
		return m.UserID()
	case wxcard.FieldWxUserID:
		return m.WxUserID()
	case wxcard.FieldAvatar:
		return m.Avatar()
	case wxcard.FieldLogo:
		return m.Logo()
	case wxcard.FieldName:
		return m.Name()
	case wxcard.FieldCompany:
		return m.Company()
	case wxcard.FieldAddress:
		return m.Address()
	case wxcard.FieldPhone:
		return m.Phone()
	case wxcard.FieldOfficialAccount:
		return m.OfficialAccount()
	case wxcard.FieldWechatAccount:
		return m.WechatAccount()
	case wxcard.FieldEmail:
		return m.Email()
	case wxcard.FieldAPIBase:
		return m.APIBase()
	case wxcard.FieldAPIKey:
		return m.APIKey()
	case wxcard.FieldAiInfo:
		return m.AiInfo()
	case wxcard.FieldIntro:
		return m.Intro()
	}
	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 *WxCardMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wxcard.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wxcard.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wxcard.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case wxcard.FieldUserID:
		return m.OldUserID(ctx)
	case wxcard.FieldWxUserID:
		return m.OldWxUserID(ctx)
	case wxcard.FieldAvatar:
		return m.OldAvatar(ctx)
	case wxcard.FieldLogo:
		return m.OldLogo(ctx)
	case wxcard.FieldName:
		return m.OldName(ctx)
	case wxcard.FieldCompany:
		return m.OldCompany(ctx)
	case wxcard.FieldAddress:
		return m.OldAddress(ctx)
	case wxcard.FieldPhone:
		return m.OldPhone(ctx)
	case wxcard.FieldOfficialAccount:
		return m.OldOfficialAccount(ctx)
	case wxcard.FieldWechatAccount:
		return m.OldWechatAccount(ctx)
	case wxcard.FieldEmail:
		return m.OldEmail(ctx)
	case wxcard.FieldAPIBase:
		return m.OldAPIBase(ctx)
	case wxcard.FieldAPIKey:
		return m.OldAPIKey(ctx)
	case wxcard.FieldAiInfo:
		return m.OldAiInfo(ctx)
	case wxcard.FieldIntro:
		return m.OldIntro(ctx)
	}
	return nil, fmt.Errorf("unknown WxCard 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 *WxCardMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wxcard.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 wxcard.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 wxcard.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 wxcard.FieldUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case wxcard.FieldWxUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxUserID(v)
		return nil
	case wxcard.FieldAvatar:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatar(v)
		return nil
	case wxcard.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	case wxcard.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case wxcard.FieldCompany:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompany(v)
		return nil
	case wxcard.FieldAddress:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAddress(v)
		return nil
	case wxcard.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(v)
		return nil
	case wxcard.FieldOfficialAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOfficialAccount(v)
		return nil
	case wxcard.FieldWechatAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWechatAccount(v)
		return nil
	case wxcard.FieldEmail:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmail(v)
		return nil
	case wxcard.FieldAPIBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIBase(v)
		return nil
	case wxcard.FieldAPIKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIKey(v)
		return nil
	case wxcard.FieldAiInfo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAiInfo(v)
		return nil
	case wxcard.FieldIntro:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIntro(v)
		return nil
	}
	return fmt.Errorf("unknown WxCard field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WxCardMutation) AddedFields() []string {
	var fields []string
	if m.adduser_id != nil {
		fields = append(fields, wxcard.FieldUserID)
	}
	if m.addwx_user_id != nil {
		fields = append(fields, wxcard.FieldWxUserID)
	}
	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 *WxCardMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case wxcard.FieldUserID:
		return m.AddedUserID()
	case wxcard.FieldWxUserID:
		return m.AddedWxUserID()
	}
	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 *WxCardMutation) AddField(name string, value ent.Value) error {
	switch name {
	case wxcard.FieldUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUserID(v)
		return nil
	case wxcard.FieldWxUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddWxUserID(v)
		return nil
	}
	return fmt.Errorf("unknown WxCard numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WxCardMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(wxcard.FieldDeletedAt) {
		fields = append(fields, wxcard.FieldDeletedAt)
	}
	if m.FieldCleared(wxcard.FieldUserID) {
		fields = append(fields, wxcard.FieldUserID)
	}
	if m.FieldCleared(wxcard.FieldWxUserID) {
		fields = append(fields, wxcard.FieldWxUserID)
	}
	if m.FieldCleared(wxcard.FieldEmail) {
		fields = append(fields, wxcard.FieldEmail)
	}
	if m.FieldCleared(wxcard.FieldAPIBase) {
		fields = append(fields, wxcard.FieldAPIBase)
	}
	if m.FieldCleared(wxcard.FieldAPIKey) {
		fields = append(fields, wxcard.FieldAPIKey)
	}
	if m.FieldCleared(wxcard.FieldAiInfo) {
		fields = append(fields, wxcard.FieldAiInfo)
	}
	if m.FieldCleared(wxcard.FieldIntro) {
		fields = append(fields, wxcard.FieldIntro)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WxCardMutation) 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 *WxCardMutation) ClearField(name string) error {
	switch name {
	case wxcard.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case wxcard.FieldUserID:
		m.ClearUserID()
		return nil
	case wxcard.FieldWxUserID:
		m.ClearWxUserID()
		return nil
	case wxcard.FieldEmail:
		m.ClearEmail()
		return nil
	case wxcard.FieldAPIBase:
		m.ClearAPIBase()
		return nil
	case wxcard.FieldAPIKey:
		m.ClearAPIKey()
		return nil
	case wxcard.FieldAiInfo:
		m.ClearAiInfo()
		return nil
	case wxcard.FieldIntro:
		m.ClearIntro()
		return nil
	}
	return fmt.Errorf("unknown WxCard 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 *WxCardMutation) ResetField(name string) error {
	switch name {
	case wxcard.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wxcard.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wxcard.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case wxcard.FieldUserID:
		m.ResetUserID()
		return nil
	case wxcard.FieldWxUserID:
		m.ResetWxUserID()
		return nil
	case wxcard.FieldAvatar:
		m.ResetAvatar()
		return nil
	case wxcard.FieldLogo:
		m.ResetLogo()
		return nil
	case wxcard.FieldName:
		m.ResetName()
		return nil
	case wxcard.FieldCompany:
		m.ResetCompany()
		return nil
	case wxcard.FieldAddress:
		m.ResetAddress()
		return nil
	case wxcard.FieldPhone:
		m.ResetPhone()
		return nil
	case wxcard.FieldOfficialAccount:
		m.ResetOfficialAccount()
		return nil
	case wxcard.FieldWechatAccount:
		m.ResetWechatAccount()
		return nil
	case wxcard.FieldEmail:
		m.ResetEmail()
		return nil
	case wxcard.FieldAPIBase:
		m.ResetAPIBase()
		return nil
	case wxcard.FieldAPIKey:
		m.ResetAPIKey()
		return nil
	case wxcard.FieldAiInfo:
		m.ResetAiInfo()
		return nil
	case wxcard.FieldIntro:
		m.ResetIntro()
		return nil
	}
	return fmt.Errorf("unknown WxCard field %s", name)
}

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

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

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

// WxCardUserMutation represents an operation that mutates the WxCardUser nodes in the graph.
type WxCardUserMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	wxid          *string
	account       *string
	avatar        *string
	nickname      *string
	remark        *string
	phone         *string
	open_id       *string
	union_id      *string
	session_key   *string
	is_vip        *int
	addis_vip     *int
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*WxCardUser, error)
	predicates    []predicate.WxCardUser
}

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

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

// newWxCardUserMutation creates new mutation for the WxCardUser entity.
func newWxCardUserMutation(c config, op Op, opts ...wxcarduserOption) *WxCardUserMutation {
	m := &WxCardUserMutation{
		config:        c,
		op:            op,
		typ:           TypeWxCardUser,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWxCardUser sets the old WxCardUser of the mutation.
func withWxCardUser(node *WxCardUser) wxcarduserOption {
	return func(m *WxCardUserMutation) {
		m.oldValue = func(context.Context) (*WxCardUser, 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 WxCardUserMutation) 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 WxCardUserMutation) 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 WxCardUser entities.
func (m *WxCardUserMutation) 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 *WxCardUserMutation) 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 *WxCardUserMutation) 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().WxCardUser.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 *WxCardUserMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WxCardUserMutation) 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 WxCardUser entity.
// If the WxCardUser 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 *WxCardUserMutation) 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 *WxCardUserMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[wxcarduser.FieldDeletedAt] = struct{}{}
}

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

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

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

// Wxid returns the value of the "wxid" field in the mutation.
func (m *WxCardUserMutation) 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 WxCardUser entity.
// If the WxCardUser 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 *WxCardUserMutation) 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 *WxCardUserMutation) ResetWxid() {
	m.wxid = nil
}

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

// Account returns the value of the "account" field in the mutation.
func (m *WxCardUserMutation) 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 WxCardUser entity.
// If the WxCardUser 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 *WxCardUserMutation) 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 *WxCardUserMutation) ResetAccount() {
	m.account = nil
}

// SetAvatar sets the "avatar" field.
func (m *WxCardUserMutation) SetAvatar(s string) {
	m.avatar = &s
}

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

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

// ResetAvatar resets all changes to the "avatar" field.
func (m *WxCardUserMutation) ResetAvatar() {
	m.avatar = nil
}

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

// Nickname returns the value of the "nickname" field in the mutation.
func (m *WxCardUserMutation) 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 WxCardUser entity.
// If the WxCardUser 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 *WxCardUserMutation) 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 *WxCardUserMutation) ResetNickname() {
	m.nickname = nil
}

// SetRemark sets the "remark" field.
func (m *WxCardUserMutation) SetRemark(s string) {
	m.remark = &s
}

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

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

// ResetRemark resets all changes to the "remark" field.
func (m *WxCardUserMutation) ResetRemark() {
	m.remark = nil
}

// SetPhone sets the "phone" field.
func (m *WxCardUserMutation) SetPhone(s string) {
	m.phone = &s
}

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

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

// ResetPhone resets all changes to the "phone" field.
func (m *WxCardUserMutation) ResetPhone() {
	m.phone = nil
}

// SetOpenID sets the "open_id" field.
func (m *WxCardUserMutation) SetOpenID(s string) {
	m.open_id = &s
}

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

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

// ResetOpenID resets all changes to the "open_id" field.
func (m *WxCardUserMutation) ResetOpenID() {
	m.open_id = nil
}

// SetUnionID sets the "union_id" field.
func (m *WxCardUserMutation) SetUnionID(s string) {
	m.union_id = &s
}

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

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

// ResetUnionID resets all changes to the "union_id" field.
func (m *WxCardUserMutation) ResetUnionID() {
	m.union_id = nil
}

// SetSessionKey sets the "session_key" field.
func (m *WxCardUserMutation) SetSessionKey(s string) {
	m.session_key = &s
}

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

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

// ResetSessionKey resets all changes to the "session_key" field.
func (m *WxCardUserMutation) ResetSessionKey() {
	m.session_key = nil
}

// SetIsVip sets the "is_vip" field.
func (m *WxCardUserMutation) SetIsVip(i int) {
	m.is_vip = &i
	m.addis_vip = nil
}

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

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

// AddIsVip adds i to the "is_vip" field.
func (m *WxCardUserMutation) AddIsVip(i int) {
	if m.addis_vip != nil {
		*m.addis_vip += i
	} else {
		m.addis_vip = &i
	}
}

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

// ResetIsVip resets all changes to the "is_vip" field.
func (m *WxCardUserMutation) ResetIsVip() {
	m.is_vip = nil
	m.addis_vip = nil
}

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

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

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

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

// Type returns the node type of this mutation (WxCardUser).
func (m *WxCardUserMutation) 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 *WxCardUserMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.created_at != nil {
		fields = append(fields, wxcarduser.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wxcarduser.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, wxcarduser.FieldDeletedAt)
	}
	if m.wxid != nil {
		fields = append(fields, wxcarduser.FieldWxid)
	}
	if m.account != nil {
		fields = append(fields, wxcarduser.FieldAccount)
	}
	if m.avatar != nil {
		fields = append(fields, wxcarduser.FieldAvatar)
	}
	if m.nickname != nil {
		fields = append(fields, wxcarduser.FieldNickname)
	}
	if m.remark != nil {
		fields = append(fields, wxcarduser.FieldRemark)
	}
	if m.phone != nil {
		fields = append(fields, wxcarduser.FieldPhone)
	}
	if m.open_id != nil {
		fields = append(fields, wxcarduser.FieldOpenID)
	}
	if m.union_id != nil {
		fields = append(fields, wxcarduser.FieldUnionID)
	}
	if m.session_key != nil {
		fields = append(fields, wxcarduser.FieldSessionKey)
	}
	if m.is_vip != nil {
		fields = append(fields, wxcarduser.FieldIsVip)
	}
	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 *WxCardUserMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wxcarduser.FieldCreatedAt:
		return m.CreatedAt()
	case wxcarduser.FieldUpdatedAt:
		return m.UpdatedAt()
	case wxcarduser.FieldDeletedAt:
		return m.DeletedAt()
	case wxcarduser.FieldWxid:
		return m.Wxid()
	case wxcarduser.FieldAccount:
		return m.Account()
	case wxcarduser.FieldAvatar:
		return m.Avatar()
	case wxcarduser.FieldNickname:
		return m.Nickname()
	case wxcarduser.FieldRemark:
		return m.Remark()
	case wxcarduser.FieldPhone:
		return m.Phone()
	case wxcarduser.FieldOpenID:
		return m.OpenID()
	case wxcarduser.FieldUnionID:
		return m.UnionID()
	case wxcarduser.FieldSessionKey:
		return m.SessionKey()
	case wxcarduser.FieldIsVip:
		return m.IsVip()
	}
	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 *WxCardUserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wxcarduser.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wxcarduser.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wxcarduser.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case wxcarduser.FieldWxid:
		return m.OldWxid(ctx)
	case wxcarduser.FieldAccount:
		return m.OldAccount(ctx)
	case wxcarduser.FieldAvatar:
		return m.OldAvatar(ctx)
	case wxcarduser.FieldNickname:
		return m.OldNickname(ctx)
	case wxcarduser.FieldRemark:
		return m.OldRemark(ctx)
	case wxcarduser.FieldPhone:
		return m.OldPhone(ctx)
	case wxcarduser.FieldOpenID:
		return m.OldOpenID(ctx)
	case wxcarduser.FieldUnionID:
		return m.OldUnionID(ctx)
	case wxcarduser.FieldSessionKey:
		return m.OldSessionKey(ctx)
	case wxcarduser.FieldIsVip:
		return m.OldIsVip(ctx)
	}
	return nil, fmt.Errorf("unknown WxCardUser 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 *WxCardUserMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wxcarduser.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 wxcarduser.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 wxcarduser.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 wxcarduser.FieldWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxid(v)
		return nil
	case wxcarduser.FieldAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccount(v)
		return nil
	case wxcarduser.FieldAvatar:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatar(v)
		return nil
	case wxcarduser.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case wxcarduser.FieldRemark:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRemark(v)
		return nil
	case wxcarduser.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(v)
		return nil
	case wxcarduser.FieldOpenID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOpenID(v)
		return nil
	case wxcarduser.FieldUnionID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUnionID(v)
		return nil
	case wxcarduser.FieldSessionKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSessionKey(v)
		return nil
	case wxcarduser.FieldIsVip:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetIsVip(v)
		return nil
	}
	return fmt.Errorf("unknown WxCardUser field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WxCardUserMutation) 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 *WxCardUserMutation) ClearField(name string) error {
	switch name {
	case wxcarduser.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown WxCardUser 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 *WxCardUserMutation) ResetField(name string) error {
	switch name {
	case wxcarduser.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wxcarduser.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wxcarduser.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case wxcarduser.FieldWxid:
		m.ResetWxid()
		return nil
	case wxcarduser.FieldAccount:
		m.ResetAccount()
		return nil
	case wxcarduser.FieldAvatar:
		m.ResetAvatar()
		return nil
	case wxcarduser.FieldNickname:
		m.ResetNickname()
		return nil
	case wxcarduser.FieldRemark:
		m.ResetRemark()
		return nil
	case wxcarduser.FieldPhone:
		m.ResetPhone()
		return nil
	case wxcarduser.FieldOpenID:
		m.ResetOpenID()
		return nil
	case wxcarduser.FieldUnionID:
		m.ResetUnionID()
		return nil
	case wxcarduser.FieldSessionKey:
		m.ResetSessionKey()
		return nil
	case wxcarduser.FieldIsVip:
		m.ResetIsVip()
		return nil
	}
	return fmt.Errorf("unknown WxCardUser field %s", name)
}

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

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

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

// WxCardVisitMutation represents an operation that mutates the WxCardVisit nodes in the graph.
type WxCardVisitMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	deleted_at    *time.Time
	user_id       *uint64
	adduser_id    *int64
	bot_id        *uint64
	addbot_id     *int64
	bot_type      *uint8
	addbot_type   *int8
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*WxCardVisit, error)
	predicates    []predicate.WxCardVisit
}

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

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

// newWxCardVisitMutation creates new mutation for the WxCardVisit entity.
func newWxCardVisitMutation(c config, op Op, opts ...wxcardvisitOption) *WxCardVisitMutation {
	m := &WxCardVisitMutation{
		config:        c,
		op:            op,
		typ:           TypeWxCardVisit,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWxCardVisit sets the old WxCardVisit of the mutation.
func withWxCardVisit(node *WxCardVisit) wxcardvisitOption {
	return func(m *WxCardVisitMutation) {
		m.oldValue = func(context.Context) (*WxCardVisit, 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 WxCardVisitMutation) 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 WxCardVisitMutation) 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 WxCardVisit entities.
func (m *WxCardVisitMutation) 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 *WxCardVisitMutation) 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 *WxCardVisitMutation) 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().WxCardVisit.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 *WxCardVisitMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

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

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WxCardVisitMutation) 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 WxCardVisit entity.
// If the WxCardVisit 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 *WxCardVisitMutation) 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 *WxCardVisitMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[wxcardvisit.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *WxCardVisitMutation) SetUserID(u uint64) {
	m.user_id = &u
	m.adduser_id = nil
}

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

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

// AddUserID adds u to the "user_id" field.
func (m *WxCardVisitMutation) AddUserID(u int64) {
	if m.adduser_id != nil {
		*m.adduser_id += u
	} else {
		m.adduser_id = &u
	}
}

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

// ClearUserID clears the value of the "user_id" field.
func (m *WxCardVisitMutation) ClearUserID() {
	m.user_id = nil
	m.adduser_id = nil
	m.clearedFields[wxcardvisit.FieldUserID] = struct{}{}
}

// UserIDCleared returns if the "user_id" field was cleared in this mutation.
func (m *WxCardVisitMutation) UserIDCleared() bool {
	_, ok := m.clearedFields[wxcardvisit.FieldUserID]
	return ok
}

// ResetUserID resets all changes to the "user_id" field.
func (m *WxCardVisitMutation) ResetUserID() {
	m.user_id = nil
	m.adduser_id = nil
	delete(m.clearedFields, wxcardvisit.FieldUserID)
}

// SetBotID sets the "bot_id" field.
func (m *WxCardVisitMutation) SetBotID(u uint64) {
	m.bot_id = &u
	m.addbot_id = nil
}

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

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

// AddBotID adds u to the "bot_id" field.
func (m *WxCardVisitMutation) AddBotID(u int64) {
	if m.addbot_id != nil {
		*m.addbot_id += u
	} else {
		m.addbot_id = &u
	}
}

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

// ResetBotID resets all changes to the "bot_id" field.
func (m *WxCardVisitMutation) ResetBotID() {
	m.bot_id = nil
	m.addbot_id = nil
}

// SetBotType sets the "bot_type" field.
func (m *WxCardVisitMutation) SetBotType(u uint8) {
	m.bot_type = &u
	m.addbot_type = nil
}

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

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

// AddBotType adds u to the "bot_type" field.
func (m *WxCardVisitMutation) AddBotType(u int8) {
	if m.addbot_type != nil {
		*m.addbot_type += u
	} else {
		m.addbot_type = &u
	}
}

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

// ResetBotType resets all changes to the "bot_type" field.
func (m *WxCardVisitMutation) ResetBotType() {
	m.bot_type = nil
	m.addbot_type = nil
}

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

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

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

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

// Type returns the node type of this mutation (WxCardVisit).
func (m *WxCardVisitMutation) 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 *WxCardVisitMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.created_at != nil {
		fields = append(fields, wxcardvisit.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wxcardvisit.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, wxcardvisit.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, wxcardvisit.FieldUserID)
	}
	if m.bot_id != nil {
		fields = append(fields, wxcardvisit.FieldBotID)
	}
	if m.bot_type != nil {
		fields = append(fields, wxcardvisit.FieldBotType)
	}
	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 *WxCardVisitMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wxcardvisit.FieldCreatedAt:
		return m.CreatedAt()
	case wxcardvisit.FieldUpdatedAt:
		return m.UpdatedAt()
	case wxcardvisit.FieldDeletedAt:
		return m.DeletedAt()
	case wxcardvisit.FieldUserID:
		return m.UserID()
	case wxcardvisit.FieldBotID:
		return m.BotID()
	case wxcardvisit.FieldBotType:
		return m.BotType()
	}
	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 *WxCardVisitMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wxcardvisit.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wxcardvisit.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wxcardvisit.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case wxcardvisit.FieldUserID:
		return m.OldUserID(ctx)
	case wxcardvisit.FieldBotID:
		return m.OldBotID(ctx)
	case wxcardvisit.FieldBotType:
		return m.OldBotType(ctx)
	}
	return nil, fmt.Errorf("unknown WxCardVisit 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 *WxCardVisitMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wxcardvisit.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 wxcardvisit.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 wxcardvisit.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 wxcardvisit.FieldUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case wxcardvisit.FieldBotID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case wxcardvisit.FieldBotType:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotType(v)
		return nil
	}
	return fmt.Errorf("unknown WxCardVisit field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WxCardVisitMutation) AddedFields() []string {
	var fields []string
	if m.adduser_id != nil {
		fields = append(fields, wxcardvisit.FieldUserID)
	}
	if m.addbot_id != nil {
		fields = append(fields, wxcardvisit.FieldBotID)
	}
	if m.addbot_type != nil {
		fields = append(fields, wxcardvisit.FieldBotType)
	}
	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 *WxCardVisitMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case wxcardvisit.FieldUserID:
		return m.AddedUserID()
	case wxcardvisit.FieldBotID:
		return m.AddedBotID()
	case wxcardvisit.FieldBotType:
		return m.AddedBotType()
	}
	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 *WxCardVisitMutation) AddField(name string, value ent.Value) error {
	switch name {
	case wxcardvisit.FieldUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUserID(v)
		return nil
	case wxcardvisit.FieldBotID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotID(v)
		return nil
	case wxcardvisit.FieldBotType:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddBotType(v)
		return nil
	}
	return fmt.Errorf("unknown WxCardVisit numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WxCardVisitMutation) 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 *WxCardVisitMutation) ClearField(name string) error {
	switch name {
	case wxcardvisit.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case wxcardvisit.FieldUserID:
		m.ClearUserID()
		return nil
	}
	return fmt.Errorf("unknown WxCardVisit 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 *WxCardVisitMutation) ResetField(name string) error {
	switch name {
	case wxcardvisit.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wxcardvisit.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wxcardvisit.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case wxcardvisit.FieldUserID:
		m.ResetUserID()
		return nil
	case wxcardvisit.FieldBotID:
		m.ResetBotID()
		return nil
	case wxcardvisit.FieldBotType:
		m.ResetBotType()
		return nil
	}
	return fmt.Errorf("unknown WxCardVisit field %s", name)
}

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

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

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