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/aliyunavatar"
	"wechat-api/ent/allocagent"
	"wechat-api/ent/apikey"
	"wechat-api/ent/batchmsg"
	"wechat-api/ent/category"
	"wechat-api/ent/chatrecords"
	"wechat-api/ent/chatsession"
	"wechat-api/ent/contact"
	"wechat-api/ent/contactfield"
	"wechat-api/ent/contactfieldtemplate"
	"wechat-api/ent/creditbalance"
	"wechat-api/ent/creditusage"
	"wechat-api/ent/custom_types"
	"wechat-api/ent/employee"
	"wechat-api/ent/employeeconfig"
	"wechat-api/ent/label"
	"wechat-api/ent/labelrelationship"
	"wechat-api/ent/labeltagging"
	"wechat-api/ent/message"
	"wechat-api/ent/messagerecords"
	"wechat-api/ent/msg"
	"wechat-api/ent/payrecharge"
	"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/usagedetail"
	"wechat-api/ent/usagestatisticday"
	"wechat-api/ent/usagestatistichour"
	"wechat-api/ent/usagestatisticmonth"
	"wechat-api/ent/usagetotal"
	"wechat-api/ent/whatsapp"
	"wechat-api/ent/whatsappchannel"
	"wechat-api/ent/workexperience"
	"wechat-api/ent/wpchatroom"
	"wechat-api/ent/wpchatroommember"
	"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"
	TypeAliyunAvatar         = "AliyunAvatar"
	TypeAllocAgent           = "AllocAgent"
	TypeApiKey               = "ApiKey"
	TypeBatchMsg             = "BatchMsg"
	TypeCategory             = "Category"
	TypeChatRecords          = "ChatRecords"
	TypeChatSession          = "ChatSession"
	TypeContact              = "Contact"
	TypeContactField         = "ContactField"
	TypeContactFieldTemplate = "ContactFieldTemplate"
	TypeCreditBalance        = "CreditBalance"
	TypeCreditUsage          = "CreditUsage"
	TypeEmployee             = "Employee"
	TypeEmployeeConfig       = "EmployeeConfig"
	TypeLabel                = "Label"
	TypeLabelRelationship    = "LabelRelationship"
	TypeLabelTagging         = "LabelTagging"
	TypeMessage              = "Message"
	TypeMessageRecords       = "MessageRecords"
	TypeMsg                  = "Msg"
	TypePayRecharge          = "PayRecharge"
	TypeServer               = "Server"
	TypeSopNode              = "SopNode"
	TypeSopStage             = "SopStage"
	TypeSopTask              = "SopTask"
	TypeToken                = "Token"
	TypeTutorial             = "Tutorial"
	TypeUsageDetail          = "UsageDetail"
	TypeUsageStatisticDay    = "UsageStatisticDay"
	TypeUsageStatisticHour   = "UsageStatisticHour"
	TypeUsageStatisticMonth  = "UsageStatisticMonth"
	TypeUsageTotal           = "UsageTotal"
	TypeWhatsapp             = "Whatsapp"
	TypeWhatsappChannel      = "WhatsappChannel"
	TypeWorkExperience       = "WorkExperience"
	TypeWpChatroom           = "WpChatroom"
	TypeWpChatroomMember     = "WpChatroomMember"
	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
	token_agent        map[uint64]struct{}
	removedtoken_agent map[uint64]struct{}
	clearedtoken_agent bool
	wa_agent           map[uint64]struct{}
	removedwa_agent    map[uint64]struct{}
	clearedwa_agent    bool
	key_agent          map[uint64]struct{}
	removedkey_agent   map[uint64]struct{}
	clearedkey_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
}

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

// ClearTokenAgent clears the "token_agent" edge to the Token entity.
func (m *AgentMutation) ClearTokenAgent() {
	m.clearedtoken_agent = true
}

// TokenAgentCleared reports if the "token_agent" edge to the Token entity was cleared.
func (m *AgentMutation) TokenAgentCleared() bool {
	return m.clearedtoken_agent
}

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

// RemovedTokenAgent returns the removed IDs of the "token_agent" edge to the Token entity.
func (m *AgentMutation) RemovedTokenAgentIDs() (ids []uint64) {
	for id := range m.removedtoken_agent {
		ids = append(ids, id)
	}
	return
}

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

// ResetTokenAgent resets all changes to the "token_agent" edge.
func (m *AgentMutation) ResetTokenAgent() {
	m.token_agent = nil
	m.clearedtoken_agent = false
	m.removedtoken_agent = nil
}

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

// ClearWaAgent clears the "wa_agent" edge to the Whatsapp entity.
func (m *AgentMutation) ClearWaAgent() {
	m.clearedwa_agent = true
}

// WaAgentCleared reports if the "wa_agent" edge to the Whatsapp entity was cleared.
func (m *AgentMutation) WaAgentCleared() bool {
	return m.clearedwa_agent
}

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

// RemovedWaAgent returns the removed IDs of the "wa_agent" edge to the Whatsapp entity.
func (m *AgentMutation) RemovedWaAgentIDs() (ids []uint64) {
	for id := range m.removedwa_agent {
		ids = append(ids, id)
	}
	return
}

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

// ResetWaAgent resets all changes to the "wa_agent" edge.
func (m *AgentMutation) ResetWaAgent() {
	m.wa_agent = nil
	m.clearedwa_agent = false
	m.removedwa_agent = nil
}

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

// ClearKeyAgent clears the "key_agent" edge to the ApiKey entity.
func (m *AgentMutation) ClearKeyAgent() {
	m.clearedkey_agent = true
}

// KeyAgentCleared reports if the "key_agent" edge to the ApiKey entity was cleared.
func (m *AgentMutation) KeyAgentCleared() bool {
	return m.clearedkey_agent
}

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

// RemovedKeyAgent returns the removed IDs of the "key_agent" edge to the ApiKey entity.
func (m *AgentMutation) RemovedKeyAgentIDs() (ids []uint64) {
	for id := range m.removedkey_agent {
		ids = append(ids, id)
	}
	return
}

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

// ResetKeyAgent resets all changes to the "key_agent" edge.
func (m *AgentMutation) ResetKeyAgent() {
	m.key_agent = nil
	m.clearedkey_agent = false
	m.removedkey_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, 4)
	if m.wx_agent != nil {
		edges = append(edges, agent.EdgeWxAgent)
	}
	if m.token_agent != nil {
		edges = append(edges, agent.EdgeTokenAgent)
	}
	if m.wa_agent != nil {
		edges = append(edges, agent.EdgeWaAgent)
	}
	if m.key_agent != nil {
		edges = append(edges, agent.EdgeKeyAgent)
	}
	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
	case agent.EdgeTokenAgent:
		ids := make([]ent.Value, 0, len(m.token_agent))
		for id := range m.token_agent {
			ids = append(ids, id)
		}
		return ids
	case agent.EdgeWaAgent:
		ids := make([]ent.Value, 0, len(m.wa_agent))
		for id := range m.wa_agent {
			ids = append(ids, id)
		}
		return ids
	case agent.EdgeKeyAgent:
		ids := make([]ent.Value, 0, len(m.key_agent))
		for id := range m.key_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, 4)
	if m.removedwx_agent != nil {
		edges = append(edges, agent.EdgeWxAgent)
	}
	if m.removedtoken_agent != nil {
		edges = append(edges, agent.EdgeTokenAgent)
	}
	if m.removedwa_agent != nil {
		edges = append(edges, agent.EdgeWaAgent)
	}
	if m.removedkey_agent != nil {
		edges = append(edges, agent.EdgeKeyAgent)
	}
	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
	case agent.EdgeTokenAgent:
		ids := make([]ent.Value, 0, len(m.removedtoken_agent))
		for id := range m.removedtoken_agent {
			ids = append(ids, id)
		}
		return ids
	case agent.EdgeWaAgent:
		ids := make([]ent.Value, 0, len(m.removedwa_agent))
		for id := range m.removedwa_agent {
			ids = append(ids, id)
		}
		return ids
	case agent.EdgeKeyAgent:
		ids := make([]ent.Value, 0, len(m.removedkey_agent))
		for id := range m.removedkey_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, 4)
	if m.clearedwx_agent {
		edges = append(edges, agent.EdgeWxAgent)
	}
	if m.clearedtoken_agent {
		edges = append(edges, agent.EdgeTokenAgent)
	}
	if m.clearedwa_agent {
		edges = append(edges, agent.EdgeWaAgent)
	}
	if m.clearedkey_agent {
		edges = append(edges, agent.EdgeKeyAgent)
	}
	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
	case agent.EdgeTokenAgent:
		return m.clearedtoken_agent
	case agent.EdgeWaAgent:
		return m.clearedwa_agent
	case agent.EdgeKeyAgent:
		return m.clearedkey_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
	case agent.EdgeTokenAgent:
		m.ResetTokenAgent()
		return nil
	case agent.EdgeWaAgent:
		m.ResetWaAgent()
		return nil
	case agent.EdgeKeyAgent:
		m.ResetKeyAgent()
		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)
}

// AliyunAvatarMutation represents an operation that mutates the AliyunAvatar nodes in the graph.
type AliyunAvatarMutation 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
	biz_id            *string
	access_key_id     *string
	access_key_secret *string
	app_id            *string
	tenant_id         *uint64
	addtenant_id      *int64
	response          *string
	token             *string
	session_id        *string
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*AliyunAvatar, error)
	predicates        []predicate.AliyunAvatar
}

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

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

// newAliyunAvatarMutation creates new mutation for the AliyunAvatar entity.
func newAliyunAvatarMutation(c config, op Op, opts ...aliyunavatarOption) *AliyunAvatarMutation {
	m := &AliyunAvatarMutation{
		config:        c,
		op:            op,
		typ:           TypeAliyunAvatar,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *AliyunAvatarMutation) 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 AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *AliyunAvatarMutation) 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 AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *AliyunAvatarMutation) 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 AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[aliyunavatar.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) 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 AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) 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 *AliyunAvatarMutation) 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 *AliyunAvatarMutation) ResetUserID() {
	m.user_id = nil
	m.adduser_id = nil
}

// SetBizID sets the "biz_id" field.
func (m *AliyunAvatarMutation) SetBizID(s string) {
	m.biz_id = &s
}

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

// OldBizID returns the old "biz_id" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldBizID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBizID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBizID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBizID: %w", err)
	}
	return oldValue.BizID, nil
}

// ResetBizID resets all changes to the "biz_id" field.
func (m *AliyunAvatarMutation) ResetBizID() {
	m.biz_id = nil
}

// SetAccessKeyID sets the "access_key_id" field.
func (m *AliyunAvatarMutation) SetAccessKeyID(s string) {
	m.access_key_id = &s
}

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

// OldAccessKeyID returns the old "access_key_id" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldAccessKeyID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAccessKeyID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAccessKeyID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAccessKeyID: %w", err)
	}
	return oldValue.AccessKeyID, nil
}

// ResetAccessKeyID resets all changes to the "access_key_id" field.
func (m *AliyunAvatarMutation) ResetAccessKeyID() {
	m.access_key_id = nil
}

// SetAccessKeySecret sets the "access_key_secret" field.
func (m *AliyunAvatarMutation) SetAccessKeySecret(s string) {
	m.access_key_secret = &s
}

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

// OldAccessKeySecret returns the old "access_key_secret" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldAccessKeySecret(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAccessKeySecret is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAccessKeySecret requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAccessKeySecret: %w", err)
	}
	return oldValue.AccessKeySecret, nil
}

// ResetAccessKeySecret resets all changes to the "access_key_secret" field.
func (m *AliyunAvatarMutation) ResetAccessKeySecret() {
	m.access_key_secret = nil
}

// SetAppID sets the "app_id" field.
func (m *AliyunAvatarMutation) SetAppID(s string) {
	m.app_id = &s
}

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

// OldAppID returns the old "app_id" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldAppID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAppID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAppID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAppID: %w", err)
	}
	return oldValue.AppID, nil
}

// ClearAppID clears the value of the "app_id" field.
func (m *AliyunAvatarMutation) ClearAppID() {
	m.app_id = nil
	m.clearedFields[aliyunavatar.FieldAppID] = struct{}{}
}

// AppIDCleared returns if the "app_id" field was cleared in this mutation.
func (m *AliyunAvatarMutation) AppIDCleared() bool {
	_, ok := m.clearedFields[aliyunavatar.FieldAppID]
	return ok
}

// ResetAppID resets all changes to the "app_id" field.
func (m *AliyunAvatarMutation) ResetAppID() {
	m.app_id = nil
	delete(m.clearedFields, aliyunavatar.FieldAppID)
}

// SetTenantID sets the "tenant_id" field.
func (m *AliyunAvatarMutation) SetTenantID(u uint64) {
	m.tenant_id = &u
	m.addtenant_id = nil
}

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

// OldTenantID returns the old "tenant_id" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldTenantID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTenantID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTenantID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTenantID: %w", err)
	}
	return oldValue.TenantID, nil
}

// AddTenantID adds u to the "tenant_id" field.
func (m *AliyunAvatarMutation) AddTenantID(u int64) {
	if m.addtenant_id != nil {
		*m.addtenant_id += u
	} else {
		m.addtenant_id = &u
	}
}

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

// ResetTenantID resets all changes to the "tenant_id" field.
func (m *AliyunAvatarMutation) ResetTenantID() {
	m.tenant_id = nil
	m.addtenant_id = nil
}

// SetResponse sets the "response" field.
func (m *AliyunAvatarMutation) SetResponse(s string) {
	m.response = &s
}

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

// OldResponse returns the old "response" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldResponse(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldResponse is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldResponse requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldResponse: %w", err)
	}
	return oldValue.Response, nil
}

// ResetResponse resets all changes to the "response" field.
func (m *AliyunAvatarMutation) ResetResponse() {
	m.response = nil
}

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

// Token returns the value of the "token" field in the mutation.
func (m *AliyunAvatarMutation) 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 AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) 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
}

// ResetToken resets all changes to the "token" field.
func (m *AliyunAvatarMutation) ResetToken() {
	m.token = nil
}

// SetSessionID sets the "session_id" field.
func (m *AliyunAvatarMutation) SetSessionID(s string) {
	m.session_id = &s
}

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

// OldSessionID returns the old "session_id" field's value of the AliyunAvatar entity.
// If the AliyunAvatar object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AliyunAvatarMutation) OldSessionID(ctx context.Context) (v string, 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
}

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

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

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

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

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

// Type returns the node type of this mutation (AliyunAvatar).
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, aliyunavatar.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, aliyunavatar.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, aliyunavatar.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, aliyunavatar.FieldUserID)
	}
	if m.biz_id != nil {
		fields = append(fields, aliyunavatar.FieldBizID)
	}
	if m.access_key_id != nil {
		fields = append(fields, aliyunavatar.FieldAccessKeyID)
	}
	if m.access_key_secret != nil {
		fields = append(fields, aliyunavatar.FieldAccessKeySecret)
	}
	if m.app_id != nil {
		fields = append(fields, aliyunavatar.FieldAppID)
	}
	if m.tenant_id != nil {
		fields = append(fields, aliyunavatar.FieldTenantID)
	}
	if m.response != nil {
		fields = append(fields, aliyunavatar.FieldResponse)
	}
	if m.token != nil {
		fields = append(fields, aliyunavatar.FieldToken)
	}
	if m.session_id != nil {
		fields = append(fields, aliyunavatar.FieldSessionID)
	}
	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 *AliyunAvatarMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case aliyunavatar.FieldCreatedAt:
		return m.CreatedAt()
	case aliyunavatar.FieldUpdatedAt:
		return m.UpdatedAt()
	case aliyunavatar.FieldDeletedAt:
		return m.DeletedAt()
	case aliyunavatar.FieldUserID:
		return m.UserID()
	case aliyunavatar.FieldBizID:
		return m.BizID()
	case aliyunavatar.FieldAccessKeyID:
		return m.AccessKeyID()
	case aliyunavatar.FieldAccessKeySecret:
		return m.AccessKeySecret()
	case aliyunavatar.FieldAppID:
		return m.AppID()
	case aliyunavatar.FieldTenantID:
		return m.TenantID()
	case aliyunavatar.FieldResponse:
		return m.Response()
	case aliyunavatar.FieldToken:
		return m.Token()
	case aliyunavatar.FieldSessionID:
		return m.SessionID()
	}
	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 *AliyunAvatarMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case aliyunavatar.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case aliyunavatar.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case aliyunavatar.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case aliyunavatar.FieldUserID:
		return m.OldUserID(ctx)
	case aliyunavatar.FieldBizID:
		return m.OldBizID(ctx)
	case aliyunavatar.FieldAccessKeyID:
		return m.OldAccessKeyID(ctx)
	case aliyunavatar.FieldAccessKeySecret:
		return m.OldAccessKeySecret(ctx)
	case aliyunavatar.FieldAppID:
		return m.OldAppID(ctx)
	case aliyunavatar.FieldTenantID:
		return m.OldTenantID(ctx)
	case aliyunavatar.FieldResponse:
		return m.OldResponse(ctx)
	case aliyunavatar.FieldToken:
		return m.OldToken(ctx)
	case aliyunavatar.FieldSessionID:
		return m.OldSessionID(ctx)
	}
	return nil, fmt.Errorf("unknown AliyunAvatar 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 *AliyunAvatarMutation) SetField(name string, value ent.Value) error {
	switch name {
	case aliyunavatar.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 aliyunavatar.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 aliyunavatar.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 aliyunavatar.FieldUserID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case aliyunavatar.FieldBizID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBizID(v)
		return nil
	case aliyunavatar.FieldAccessKeyID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccessKeyID(v)
		return nil
	case aliyunavatar.FieldAccessKeySecret:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccessKeySecret(v)
		return nil
	case aliyunavatar.FieldAppID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAppID(v)
		return nil
	case aliyunavatar.FieldTenantID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTenantID(v)
		return nil
	case aliyunavatar.FieldResponse:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetResponse(v)
		return nil
	case aliyunavatar.FieldToken:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToken(v)
		return nil
	case aliyunavatar.FieldSessionID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSessionID(v)
		return nil
	}
	return fmt.Errorf("unknown AliyunAvatar field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *AliyunAvatarMutation) AddedFields() []string {
	var fields []string
	if m.adduser_id != nil {
		fields = append(fields, aliyunavatar.FieldUserID)
	}
	if m.addtenant_id != nil {
		fields = append(fields, aliyunavatar.FieldTenantID)
	}
	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 *AliyunAvatarMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case aliyunavatar.FieldUserID:
		return m.AddedUserID()
	case aliyunavatar.FieldTenantID:
		return m.AddedTenantID()
	}
	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 *AliyunAvatarMutation) AddField(name string, value ent.Value) error {
	switch name {
	case aliyunavatar.FieldUserID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUserID(v)
		return nil
	case aliyunavatar.FieldTenantID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTenantID(v)
		return nil
	}
	return fmt.Errorf("unknown AliyunAvatar numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *AliyunAvatarMutation) 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 *AliyunAvatarMutation) ClearField(name string) error {
	switch name {
	case aliyunavatar.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case aliyunavatar.FieldAppID:
		m.ClearAppID()
		return nil
	}
	return fmt.Errorf("unknown AliyunAvatar 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 *AliyunAvatarMutation) ResetField(name string) error {
	switch name {
	case aliyunavatar.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case aliyunavatar.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case aliyunavatar.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case aliyunavatar.FieldUserID:
		m.ResetUserID()
		return nil
	case aliyunavatar.FieldBizID:
		m.ResetBizID()
		return nil
	case aliyunavatar.FieldAccessKeyID:
		m.ResetAccessKeyID()
		return nil
	case aliyunavatar.FieldAccessKeySecret:
		m.ResetAccessKeySecret()
		return nil
	case aliyunavatar.FieldAppID:
		m.ResetAppID()
		return nil
	case aliyunavatar.FieldTenantID:
		m.ResetTenantID()
		return nil
	case aliyunavatar.FieldResponse:
		m.ResetResponse()
		return nil
	case aliyunavatar.FieldToken:
		m.ResetToken()
		return nil
	case aliyunavatar.FieldSessionID:
		m.ResetSessionID()
		return nil
	}
	return fmt.Errorf("unknown AliyunAvatar field %s", name)
}

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

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

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

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

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

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

// newAllocAgentMutation creates new mutation for the AllocAgent entity.
func newAllocAgentMutation(c config, op Op, opts ...allocagentOption) *AllocAgentMutation {
	m := &AllocAgentMutation{
		config:        c,
		op:            op,
		typ:           TypeAllocAgent,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *AllocAgentMutation) 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 AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *AllocAgentMutation) 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 AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *AllocAgentMutation) 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 AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[allocagent.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *AllocAgentMutation) SetUserID(s string) {
	m.user_id = &s
}

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

// OldUserID returns the old "user_id" field's value of the AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) OldUserID(ctx context.Context) (v string, 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
}

// ClearUserID clears the value of the "user_id" field.
func (m *AllocAgentMutation) ClearUserID() {
	m.user_id = nil
	m.clearedFields[allocagent.FieldUserID] = struct{}{}
}

// UserIDCleared returns if the "user_id" field was cleared in this mutation.
func (m *AllocAgentMutation) UserIDCleared() bool {
	_, ok := m.clearedFields[allocagent.FieldUserID]
	return ok
}

// ResetUserID resets all changes to the "user_id" field.
func (m *AllocAgentMutation) ResetUserID() {
	m.user_id = nil
	delete(m.clearedFields, allocagent.FieldUserID)
}

// SetOrganizationID sets the "organization_id" field.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) 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 AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) 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 *AllocAgentMutation) 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 *AllocAgentMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[allocagent.FieldOrganizationID] = struct{}{}
}

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

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

// SetAgents sets the "agents" field.
func (m *AllocAgentMutation) SetAgents(u []uint64) {
	m.agents = &u
	m.appendagents = nil
}

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

// OldAgents returns the old "agents" field's value of the AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) OldAgents(ctx context.Context) (v []uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAgents is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAgents requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAgents: %w", err)
	}
	return oldValue.Agents, nil
}

// AppendAgents adds u to the "agents" field.
func (m *AllocAgentMutation) AppendAgents(u []uint64) {
	m.appendagents = append(m.appendagents, u...)
}

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

// ResetAgents resets all changes to the "agents" field.
func (m *AllocAgentMutation) ResetAgents() {
	m.agents = nil
	m.appendagents = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *AllocAgentMutation) 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 AllocAgent entity.
// If the AllocAgent object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) 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 *AllocAgentMutation) 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 *AllocAgentMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[allocagent.FieldStatus] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (AllocAgent).
func (m *AllocAgentMutation) 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 *AllocAgentMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, allocagent.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, allocagent.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, allocagent.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, allocagent.FieldUserID)
	}
	if m.organization_id != nil {
		fields = append(fields, allocagent.FieldOrganizationID)
	}
	if m.agents != nil {
		fields = append(fields, allocagent.FieldAgents)
	}
	if m.status != nil {
		fields = append(fields, allocagent.FieldStatus)
	}
	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 *AllocAgentMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case allocagent.FieldCreatedAt:
		return m.CreatedAt()
	case allocagent.FieldUpdatedAt:
		return m.UpdatedAt()
	case allocagent.FieldDeletedAt:
		return m.DeletedAt()
	case allocagent.FieldUserID:
		return m.UserID()
	case allocagent.FieldOrganizationID:
		return m.OrganizationID()
	case allocagent.FieldAgents:
		return m.Agents()
	case allocagent.FieldStatus:
		return m.Status()
	}
	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 *AllocAgentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case allocagent.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case allocagent.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case allocagent.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case allocagent.FieldUserID:
		return m.OldUserID(ctx)
	case allocagent.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case allocagent.FieldAgents:
		return m.OldAgents(ctx)
	case allocagent.FieldStatus:
		return m.OldStatus(ctx)
	}
	return nil, fmt.Errorf("unknown AllocAgent 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 *AllocAgentMutation) SetField(name string, value ent.Value) error {
	switch name {
	case allocagent.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 allocagent.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 allocagent.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 allocagent.FieldUserID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case allocagent.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case allocagent.FieldAgents:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAgents(v)
		return nil
	case allocagent.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	}
	return fmt.Errorf("unknown AllocAgent field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *AllocAgentMutation) 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 *AllocAgentMutation) ClearField(name string) error {
	switch name {
	case allocagent.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case allocagent.FieldUserID:
		m.ClearUserID()
		return nil
	case allocagent.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	case allocagent.FieldStatus:
		m.ClearStatus()
		return nil
	}
	return fmt.Errorf("unknown AllocAgent 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 *AllocAgentMutation) ResetField(name string) error {
	switch name {
	case allocagent.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case allocagent.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case allocagent.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case allocagent.FieldUserID:
		m.ResetUserID()
		return nil
	case allocagent.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case allocagent.FieldAgents:
		m.ResetAgents()
		return nil
	case allocagent.FieldStatus:
		m.ResetStatus()
		return nil
	}
	return fmt.Errorf("unknown AllocAgent field %s", name)
}

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

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

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

// ApiKeyMutation represents an operation that mutates the ApiKey nodes in the graph.
type ApiKeyMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	title              *string
	key                *string
	organization_id    *uint64
	addorganization_id *int64
	custom_agent_base  *string
	custom_agent_key   *string
	openai_base        *string
	openai_key         *string
	clearedFields      map[string]struct{}
	agent              *uint64
	clearedagent       bool
	done               bool
	oldValue           func(context.Context) (*ApiKey, error)
	predicates         []predicate.ApiKey
}

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

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

// newApiKeyMutation creates new mutation for the ApiKey entity.
func newApiKeyMutation(c config, op Op, opts ...apikeyOption) *ApiKeyMutation {
	m := &ApiKeyMutation{
		config:        c,
		op:            op,
		typ:           TypeApiKey,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[apikey.FieldDeletedAt] = struct{}{}
}

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

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

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

// Title returns the value of the "title" field in the mutation.
func (m *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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
}

// ClearTitle clears the value of the "title" field.
func (m *ApiKeyMutation) ClearTitle() {
	m.title = nil
	m.clearedFields[apikey.FieldTitle] = struct{}{}
}

// TitleCleared returns if the "title" field was cleared in this mutation.
func (m *ApiKeyMutation) TitleCleared() bool {
	_, ok := m.clearedFields[apikey.FieldTitle]
	return ok
}

// ResetTitle resets all changes to the "title" field.
func (m *ApiKeyMutation) ResetTitle() {
	m.title = nil
	delete(m.clearedFields, apikey.FieldTitle)
}

// SetKey sets the "key" field.
func (m *ApiKeyMutation) SetKey(s string) {
	m.key = &s
}

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

// OldKey returns the old "key" field's value of the ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) OldKey(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldKey is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldKey requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldKey: %w", err)
	}
	return oldValue.Key, nil
}

// ClearKey clears the value of the "key" field.
func (m *ApiKeyMutation) ClearKey() {
	m.key = nil
	m.clearedFields[apikey.FieldKey] = struct{}{}
}

// KeyCleared returns if the "key" field was cleared in this mutation.
func (m *ApiKeyMutation) KeyCleared() bool {
	_, ok := m.clearedFields[apikey.FieldKey]
	return ok
}

// ResetKey resets all changes to the "key" field.
func (m *ApiKeyMutation) ResetKey() {
	m.key = nil
	delete(m.clearedFields, apikey.FieldKey)
}

// SetOrganizationID sets the "organization_id" field.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) 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 *ApiKeyMutation) 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 *ApiKeyMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

// SetAgentID sets the "agent_id" field.
func (m *ApiKeyMutation) SetAgentID(u uint64) {
	m.agent = &u
}

// AgentID returns the value of the "agent_id" field in the mutation.
func (m *ApiKeyMutation) 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 ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) ResetAgentID() {
	m.agent = nil
}

// SetCustomAgentBase sets the "custom_agent_base" field.
func (m *ApiKeyMutation) SetCustomAgentBase(s string) {
	m.custom_agent_base = &s
}

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

// OldCustomAgentBase returns the old "custom_agent_base" field's value of the ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) OldCustomAgentBase(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCustomAgentBase is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCustomAgentBase requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCustomAgentBase: %w", err)
	}
	return oldValue.CustomAgentBase, nil
}

// ClearCustomAgentBase clears the value of the "custom_agent_base" field.
func (m *ApiKeyMutation) ClearCustomAgentBase() {
	m.custom_agent_base = nil
	m.clearedFields[apikey.FieldCustomAgentBase] = struct{}{}
}

// CustomAgentBaseCleared returns if the "custom_agent_base" field was cleared in this mutation.
func (m *ApiKeyMutation) CustomAgentBaseCleared() bool {
	_, ok := m.clearedFields[apikey.FieldCustomAgentBase]
	return ok
}

// ResetCustomAgentBase resets all changes to the "custom_agent_base" field.
func (m *ApiKeyMutation) ResetCustomAgentBase() {
	m.custom_agent_base = nil
	delete(m.clearedFields, apikey.FieldCustomAgentBase)
}

// SetCustomAgentKey sets the "custom_agent_key" field.
func (m *ApiKeyMutation) SetCustomAgentKey(s string) {
	m.custom_agent_key = &s
}

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

// OldCustomAgentKey returns the old "custom_agent_key" field's value of the ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) OldCustomAgentKey(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCustomAgentKey is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCustomAgentKey requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCustomAgentKey: %w", err)
	}
	return oldValue.CustomAgentKey, nil
}

// ClearCustomAgentKey clears the value of the "custom_agent_key" field.
func (m *ApiKeyMutation) ClearCustomAgentKey() {
	m.custom_agent_key = nil
	m.clearedFields[apikey.FieldCustomAgentKey] = struct{}{}
}

// CustomAgentKeyCleared returns if the "custom_agent_key" field was cleared in this mutation.
func (m *ApiKeyMutation) CustomAgentKeyCleared() bool {
	_, ok := m.clearedFields[apikey.FieldCustomAgentKey]
	return ok
}

// ResetCustomAgentKey resets all changes to the "custom_agent_key" field.
func (m *ApiKeyMutation) ResetCustomAgentKey() {
	m.custom_agent_key = nil
	delete(m.clearedFields, apikey.FieldCustomAgentKey)
}

// SetOpenaiBase sets the "openai_base" field.
func (m *ApiKeyMutation) SetOpenaiBase(s string) {
	m.openai_base = &s
}

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

// OldOpenaiBase returns the old "openai_base" field's value of the ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) OldOpenaiBase(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOpenaiBase is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOpenaiBase requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOpenaiBase: %w", err)
	}
	return oldValue.OpenaiBase, nil
}

// ClearOpenaiBase clears the value of the "openai_base" field.
func (m *ApiKeyMutation) ClearOpenaiBase() {
	m.openai_base = nil
	m.clearedFields[apikey.FieldOpenaiBase] = struct{}{}
}

// OpenaiBaseCleared returns if the "openai_base" field was cleared in this mutation.
func (m *ApiKeyMutation) OpenaiBaseCleared() bool {
	_, ok := m.clearedFields[apikey.FieldOpenaiBase]
	return ok
}

// ResetOpenaiBase resets all changes to the "openai_base" field.
func (m *ApiKeyMutation) ResetOpenaiBase() {
	m.openai_base = nil
	delete(m.clearedFields, apikey.FieldOpenaiBase)
}

// SetOpenaiKey sets the "openai_key" field.
func (m *ApiKeyMutation) SetOpenaiKey(s string) {
	m.openai_key = &s
}

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

// OldOpenaiKey returns the old "openai_key" field's value of the ApiKey entity.
// If the ApiKey object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ApiKeyMutation) OldOpenaiKey(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOpenaiKey is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOpenaiKey requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOpenaiKey: %w", err)
	}
	return oldValue.OpenaiKey, nil
}

// ClearOpenaiKey clears the value of the "openai_key" field.
func (m *ApiKeyMutation) ClearOpenaiKey() {
	m.openai_key = nil
	m.clearedFields[apikey.FieldOpenaiKey] = struct{}{}
}

// OpenaiKeyCleared returns if the "openai_key" field was cleared in this mutation.
func (m *ApiKeyMutation) OpenaiKeyCleared() bool {
	_, ok := m.clearedFields[apikey.FieldOpenaiKey]
	return ok
}

// ResetOpenaiKey resets all changes to the "openai_key" field.
func (m *ApiKeyMutation) ResetOpenaiKey() {
	m.openai_key = nil
	delete(m.clearedFields, apikey.FieldOpenaiKey)
}

// ClearAgent clears the "agent" edge to the Agent entity.
func (m *ApiKeyMutation) ClearAgent() {
	m.clearedagent = true
	m.clearedFields[apikey.FieldAgentID] = struct{}{}
}

// AgentCleared reports if the "agent" edge to the Agent entity was cleared.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) AgentIDs() (ids []uint64) {
	if id := m.agent; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetAgent resets all changes to the "agent" edge.
func (m *ApiKeyMutation) ResetAgent() {
	m.agent = nil
	m.clearedagent = false
}

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

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

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

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

// Type returns the node type of this mutation (ApiKey).
func (m *ApiKeyMutation) 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 *ApiKeyMutation) Fields() []string {
	fields := make([]string, 0, 11)
	if m.created_at != nil {
		fields = append(fields, apikey.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, apikey.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, apikey.FieldDeletedAt)
	}
	if m.title != nil {
		fields = append(fields, apikey.FieldTitle)
	}
	if m.key != nil {
		fields = append(fields, apikey.FieldKey)
	}
	if m.organization_id != nil {
		fields = append(fields, apikey.FieldOrganizationID)
	}
	if m.agent != nil {
		fields = append(fields, apikey.FieldAgentID)
	}
	if m.custom_agent_base != nil {
		fields = append(fields, apikey.FieldCustomAgentBase)
	}
	if m.custom_agent_key != nil {
		fields = append(fields, apikey.FieldCustomAgentKey)
	}
	if m.openai_base != nil {
		fields = append(fields, apikey.FieldOpenaiBase)
	}
	if m.openai_key != nil {
		fields = append(fields, apikey.FieldOpenaiKey)
	}
	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 *ApiKeyMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case apikey.FieldCreatedAt:
		return m.CreatedAt()
	case apikey.FieldUpdatedAt:
		return m.UpdatedAt()
	case apikey.FieldDeletedAt:
		return m.DeletedAt()
	case apikey.FieldTitle:
		return m.Title()
	case apikey.FieldKey:
		return m.Key()
	case apikey.FieldOrganizationID:
		return m.OrganizationID()
	case apikey.FieldAgentID:
		return m.AgentID()
	case apikey.FieldCustomAgentBase:
		return m.CustomAgentBase()
	case apikey.FieldCustomAgentKey:
		return m.CustomAgentKey()
	case apikey.FieldOpenaiBase:
		return m.OpenaiBase()
	case apikey.FieldOpenaiKey:
		return m.OpenaiKey()
	}
	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 *ApiKeyMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case apikey.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case apikey.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case apikey.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case apikey.FieldTitle:
		return m.OldTitle(ctx)
	case apikey.FieldKey:
		return m.OldKey(ctx)
	case apikey.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case apikey.FieldAgentID:
		return m.OldAgentID(ctx)
	case apikey.FieldCustomAgentBase:
		return m.OldCustomAgentBase(ctx)
	case apikey.FieldCustomAgentKey:
		return m.OldCustomAgentKey(ctx)
	case apikey.FieldOpenaiBase:
		return m.OldOpenaiBase(ctx)
	case apikey.FieldOpenaiKey:
		return m.OldOpenaiKey(ctx)
	}
	return nil, fmt.Errorf("unknown ApiKey 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 *ApiKeyMutation) SetField(name string, value ent.Value) error {
	switch name {
	case apikey.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 apikey.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 apikey.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 apikey.FieldTitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTitle(v)
		return nil
	case apikey.FieldKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetKey(v)
		return nil
	case apikey.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case apikey.FieldAgentID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAgentID(v)
		return nil
	case apikey.FieldCustomAgentBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCustomAgentBase(v)
		return nil
	case apikey.FieldCustomAgentKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCustomAgentKey(v)
		return nil
	case apikey.FieldOpenaiBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOpenaiBase(v)
		return nil
	case apikey.FieldOpenaiKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOpenaiKey(v)
		return nil
	}
	return fmt.Errorf("unknown ApiKey field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ApiKeyMutation) AddedFields() []string {
	var fields []string
	if m.addorganization_id != nil {
		fields = append(fields, apikey.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 *ApiKeyMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case apikey.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 *ApiKeyMutation) AddField(name string, value ent.Value) error {
	switch name {
	case apikey.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 ApiKey numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ApiKeyMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(apikey.FieldDeletedAt) {
		fields = append(fields, apikey.FieldDeletedAt)
	}
	if m.FieldCleared(apikey.FieldTitle) {
		fields = append(fields, apikey.FieldTitle)
	}
	if m.FieldCleared(apikey.FieldKey) {
		fields = append(fields, apikey.FieldKey)
	}
	if m.FieldCleared(apikey.FieldCustomAgentBase) {
		fields = append(fields, apikey.FieldCustomAgentBase)
	}
	if m.FieldCleared(apikey.FieldCustomAgentKey) {
		fields = append(fields, apikey.FieldCustomAgentKey)
	}
	if m.FieldCleared(apikey.FieldOpenaiBase) {
		fields = append(fields, apikey.FieldOpenaiBase)
	}
	if m.FieldCleared(apikey.FieldOpenaiKey) {
		fields = append(fields, apikey.FieldOpenaiKey)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ApiKeyMutation) 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 *ApiKeyMutation) ClearField(name string) error {
	switch name {
	case apikey.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case apikey.FieldTitle:
		m.ClearTitle()
		return nil
	case apikey.FieldKey:
		m.ClearKey()
		return nil
	case apikey.FieldCustomAgentBase:
		m.ClearCustomAgentBase()
		return nil
	case apikey.FieldCustomAgentKey:
		m.ClearCustomAgentKey()
		return nil
	case apikey.FieldOpenaiBase:
		m.ClearOpenaiBase()
		return nil
	case apikey.FieldOpenaiKey:
		m.ClearOpenaiKey()
		return nil
	}
	return fmt.Errorf("unknown ApiKey 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 *ApiKeyMutation) ResetField(name string) error {
	switch name {
	case apikey.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case apikey.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case apikey.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case apikey.FieldTitle:
		m.ResetTitle()
		return nil
	case apikey.FieldKey:
		m.ResetKey()
		return nil
	case apikey.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case apikey.FieldAgentID:
		m.ResetAgentID()
		return nil
	case apikey.FieldCustomAgentBase:
		m.ResetCustomAgentBase()
		return nil
	case apikey.FieldCustomAgentKey:
		m.ResetCustomAgentKey()
		return nil
	case apikey.FieldOpenaiBase:
		m.ResetOpenaiBase()
		return nil
	case apikey.FieldOpenaiKey:
		m.ResetOpenaiKey()
		return nil
	}
	return fmt.Errorf("unknown ApiKey field %s", name)
}

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

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *ApiKeyMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case apikey.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 *ApiKeyMutation) 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 *ApiKeyMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ApiKeyMutation) EdgeCleared(name string) bool {
	switch name {
	case apikey.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 *ApiKeyMutation) ClearEdge(name string) error {
	switch name {
	case apikey.EdgeAgent:
		m.ClearAgent()
		return nil
	}
	return fmt.Errorf("unknown ApiKey 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 *ApiKeyMutation) ResetEdge(name string) error {
	switch name {
	case apikey.EdgeAgent:
		m.ResetAgent()
		return nil
	}
	return fmt.Errorf("unknown ApiKey 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
	ctype              *uint64
	addctype           *int64
	cc                 *string
	phone              *string
	template_name      *string
	template_code      *string
	lang               *string
	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
}

// SetCtype sets the "ctype" field.
func (m *BatchMsgMutation) SetCtype(u uint64) {
	m.ctype = &u
	m.addctype = nil
}

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

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

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

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

// ResetCtype resets all changes to the "ctype" field.
func (m *BatchMsgMutation) ResetCtype() {
	m.ctype = nil
	m.addctype = nil
}

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

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

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

// ClearCc clears the value of the "cc" field.
func (m *BatchMsgMutation) ClearCc() {
	m.cc = nil
	m.clearedFields[batchmsg.FieldCc] = struct{}{}
}

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

// ResetCc resets all changes to the "cc" field.
func (m *BatchMsgMutation) ResetCc() {
	m.cc = nil
	delete(m.clearedFields, batchmsg.FieldCc)
}

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

// Phone returns the value of the "phone" field in the mutation.
func (m *BatchMsgMutation) 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 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) 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
}

// ClearPhone clears the value of the "phone" field.
func (m *BatchMsgMutation) ClearPhone() {
	m.phone = nil
	m.clearedFields[batchmsg.FieldPhone] = struct{}{}
}

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

// ResetPhone resets all changes to the "phone" field.
func (m *BatchMsgMutation) ResetPhone() {
	m.phone = nil
	delete(m.clearedFields, batchmsg.FieldPhone)
}

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

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

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

// ClearTemplateName clears the value of the "template_name" field.
func (m *BatchMsgMutation) ClearTemplateName() {
	m.template_name = nil
	m.clearedFields[batchmsg.FieldTemplateName] = struct{}{}
}

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

// ResetTemplateName resets all changes to the "template_name" field.
func (m *BatchMsgMutation) ResetTemplateName() {
	m.template_name = nil
	delete(m.clearedFields, batchmsg.FieldTemplateName)
}

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

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

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

// ClearTemplateCode clears the value of the "template_code" field.
func (m *BatchMsgMutation) ClearTemplateCode() {
	m.template_code = nil
	m.clearedFields[batchmsg.FieldTemplateCode] = struct{}{}
}

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

// ResetTemplateCode resets all changes to the "template_code" field.
func (m *BatchMsgMutation) ResetTemplateCode() {
	m.template_code = nil
	delete(m.clearedFields, batchmsg.FieldTemplateCode)
}

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

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

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

// ClearLang clears the value of the "lang" field.
func (m *BatchMsgMutation) ClearLang() {
	m.lang = nil
	m.clearedFields[batchmsg.FieldLang] = struct{}{}
}

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

// ResetLang resets all changes to the "lang" field.
func (m *BatchMsgMutation) ResetLang() {
	m.lang = nil
	delete(m.clearedFields, batchmsg.FieldLang)
}

// 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, 24)
	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)
	}
	if m.ctype != nil {
		fields = append(fields, batchmsg.FieldCtype)
	}
	if m.cc != nil {
		fields = append(fields, batchmsg.FieldCc)
	}
	if m.phone != nil {
		fields = append(fields, batchmsg.FieldPhone)
	}
	if m.template_name != nil {
		fields = append(fields, batchmsg.FieldTemplateName)
	}
	if m.template_code != nil {
		fields = append(fields, batchmsg.FieldTemplateCode)
	}
	if m.lang != nil {
		fields = append(fields, batchmsg.FieldLang)
	}
	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()
	case batchmsg.FieldCtype:
		return m.Ctype()
	case batchmsg.FieldCc:
		return m.Cc()
	case batchmsg.FieldPhone:
		return m.Phone()
	case batchmsg.FieldTemplateName:
		return m.TemplateName()
	case batchmsg.FieldTemplateCode:
		return m.TemplateCode()
	case batchmsg.FieldLang:
		return m.Lang()
	}
	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)
	case batchmsg.FieldCtype:
		return m.OldCtype(ctx)
	case batchmsg.FieldCc:
		return m.OldCc(ctx)
	case batchmsg.FieldPhone:
		return m.OldPhone(ctx)
	case batchmsg.FieldTemplateName:
		return m.OldTemplateName(ctx)
	case batchmsg.FieldTemplateCode:
		return m.OldTemplateCode(ctx)
	case batchmsg.FieldLang:
		return m.OldLang(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
	case batchmsg.FieldCtype:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCtype(v)
		return nil
	case batchmsg.FieldCc:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCc(v)
		return nil
	case batchmsg.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(v)
		return nil
	case batchmsg.FieldTemplateName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTemplateName(v)
		return nil
	case batchmsg.FieldTemplateCode:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTemplateCode(v)
		return nil
	case batchmsg.FieldLang:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLang(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)
	}
	if m.addctype != nil {
		fields = append(fields, batchmsg.FieldCtype)
	}
	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()
	case batchmsg.FieldCtype:
		return m.AddedCtype()
	}
	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
	case batchmsg.FieldCtype:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCtype(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)
	}
	if m.FieldCleared(batchmsg.FieldCc) {
		fields = append(fields, batchmsg.FieldCc)
	}
	if m.FieldCleared(batchmsg.FieldPhone) {
		fields = append(fields, batchmsg.FieldPhone)
	}
	if m.FieldCleared(batchmsg.FieldTemplateName) {
		fields = append(fields, batchmsg.FieldTemplateName)
	}
	if m.FieldCleared(batchmsg.FieldTemplateCode) {
		fields = append(fields, batchmsg.FieldTemplateCode)
	}
	if m.FieldCleared(batchmsg.FieldLang) {
		fields = append(fields, batchmsg.FieldLang)
	}
	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
	case batchmsg.FieldCc:
		m.ClearCc()
		return nil
	case batchmsg.FieldPhone:
		m.ClearPhone()
		return nil
	case batchmsg.FieldTemplateName:
		m.ClearTemplateName()
		return nil
	case batchmsg.FieldTemplateCode:
		m.ClearTemplateCode()
		return nil
	case batchmsg.FieldLang:
		m.ClearLang()
		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
	case batchmsg.FieldCtype:
		m.ResetCtype()
		return nil
	case batchmsg.FieldCc:
		m.ResetCc()
		return nil
	case batchmsg.FieldPhone:
		m.ResetPhone()
		return nil
	case batchmsg.FieldTemplateName:
		m.ResetTemplateName()
		return nil
	case batchmsg.FieldTemplateCode:
		m.ResetTemplateCode()
		return nil
	case batchmsg.FieldLang:
		m.ResetLang()
		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
	ctype                        *uint64
	addctype                     *int64
	cage                         *int
	addcage                      *int
	cname                        *string
	carea                        *string
	cbirthday                    *string
	cbirtharea                   *string
	cidcard_no                   *string
	ctitle                       *string
	cc                           *string
	phone                        *string
	clearedFields                map[string]struct{}
	contact_relationships        map[uint64]struct{}
	removedcontact_relationships map[uint64]struct{}
	clearedcontact_relationships bool
	contact_fields               map[uint64]struct{}
	removedcontact_fields        map[uint64]struct{}
	clearedcontact_fields        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)
}

// SetCtype sets the "ctype" field.
func (m *ContactMutation) SetCtype(u uint64) {
	m.ctype = &u
	m.addctype = nil
}

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

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

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

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

// ResetCtype resets all changes to the "ctype" field.
func (m *ContactMutation) ResetCtype() {
	m.ctype = nil
	m.addctype = nil
}

// SetCage sets the "cage" field.
func (m *ContactMutation) SetCage(i int) {
	m.cage = &i
	m.addcage = nil
}

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

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

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

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

// ResetCage resets all changes to the "cage" field.
func (m *ContactMutation) ResetCage() {
	m.cage = nil
	m.addcage = nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Phone returns the value of the "phone" field in the mutation.
func (m *ContactMutation) 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 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) 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 *ContactMutation) ResetPhone() {
	m.phone = nil
}

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

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

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

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

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

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

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

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

// ClearContactFields clears the "contact_fields" edge to the ContactField entity.
func (m *ContactMutation) ClearContactFields() {
	m.clearedcontact_fields = true
}

// ContactFieldsCleared reports if the "contact_fields" edge to the ContactField entity was cleared.
func (m *ContactMutation) ContactFieldsCleared() bool {
	return m.clearedcontact_fields
}

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

// RemovedContactFields returns the removed IDs of the "contact_fields" edge to the ContactField entity.
func (m *ContactMutation) RemovedContactFieldsIDs() (ids []uint64) {
	for id := range m.removedcontact_fields {
		ids = append(ids, id)
	}
	return
}

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

// ResetContactFields resets all changes to the "contact_fields" edge.
func (m *ContactMutation) ResetContactFields() {
	m.contact_fields = nil
	m.clearedcontact_fields = false
	m.removedcontact_fields = 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, 30)
	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)
	}
	if m.ctype != nil {
		fields = append(fields, contact.FieldCtype)
	}
	if m.cage != nil {
		fields = append(fields, contact.FieldCage)
	}
	if m.cname != nil {
		fields = append(fields, contact.FieldCname)
	}
	if m.carea != nil {
		fields = append(fields, contact.FieldCarea)
	}
	if m.cbirthday != nil {
		fields = append(fields, contact.FieldCbirthday)
	}
	if m.cbirtharea != nil {
		fields = append(fields, contact.FieldCbirtharea)
	}
	if m.cidcard_no != nil {
		fields = append(fields, contact.FieldCidcardNo)
	}
	if m.ctitle != nil {
		fields = append(fields, contact.FieldCtitle)
	}
	if m.cc != nil {
		fields = append(fields, contact.FieldCc)
	}
	if m.phone != nil {
		fields = append(fields, contact.FieldPhone)
	}
	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()
	case contact.FieldCtype:
		return m.Ctype()
	case contact.FieldCage:
		return m.Cage()
	case contact.FieldCname:
		return m.Cname()
	case contact.FieldCarea:
		return m.Carea()
	case contact.FieldCbirthday:
		return m.Cbirthday()
	case contact.FieldCbirtharea:
		return m.Cbirtharea()
	case contact.FieldCidcardNo:
		return m.CidcardNo()
	case contact.FieldCtitle:
		return m.Ctitle()
	case contact.FieldCc:
		return m.Cc()
	case contact.FieldPhone:
		return m.Phone()
	}
	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)
	case contact.FieldCtype:
		return m.OldCtype(ctx)
	case contact.FieldCage:
		return m.OldCage(ctx)
	case contact.FieldCname:
		return m.OldCname(ctx)
	case contact.FieldCarea:
		return m.OldCarea(ctx)
	case contact.FieldCbirthday:
		return m.OldCbirthday(ctx)
	case contact.FieldCbirtharea:
		return m.OldCbirtharea(ctx)
	case contact.FieldCidcardNo:
		return m.OldCidcardNo(ctx)
	case contact.FieldCtitle:
		return m.OldCtitle(ctx)
	case contact.FieldCc:
		return m.OldCc(ctx)
	case contact.FieldPhone:
		return m.OldPhone(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
	case contact.FieldCtype:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCtype(v)
		return nil
	case contact.FieldCage:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCage(v)
		return nil
	case contact.FieldCname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCname(v)
		return nil
	case contact.FieldCarea:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCarea(v)
		return nil
	case contact.FieldCbirthday:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCbirthday(v)
		return nil
	case contact.FieldCbirtharea:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCbirtharea(v)
		return nil
	case contact.FieldCidcardNo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCidcardNo(v)
		return nil
	case contact.FieldCtitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCtitle(v)
		return nil
	case contact.FieldCc:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCc(v)
		return nil
	case contact.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(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)
	}
	if m.addctype != nil {
		fields = append(fields, contact.FieldCtype)
	}
	if m.addcage != nil {
		fields = append(fields, contact.FieldCage)
	}
	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()
	case contact.FieldCtype:
		return m.AddedCtype()
	case contact.FieldCage:
		return m.AddedCage()
	}
	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
	case contact.FieldCtype:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCtype(v)
		return nil
	case contact.FieldCage:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCage(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
	case contact.FieldCtype:
		m.ResetCtype()
		return nil
	case contact.FieldCage:
		m.ResetCage()
		return nil
	case contact.FieldCname:
		m.ResetCname()
		return nil
	case contact.FieldCarea:
		m.ResetCarea()
		return nil
	case contact.FieldCbirthday:
		m.ResetCbirthday()
		return nil
	case contact.FieldCbirtharea:
		m.ResetCbirtharea()
		return nil
	case contact.FieldCidcardNo:
		m.ResetCidcardNo()
		return nil
	case contact.FieldCtitle:
		m.ResetCtitle()
		return nil
	case contact.FieldCc:
		m.ResetCc()
		return nil
	case contact.FieldPhone:
		m.ResetPhone()
		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, 3)
	if m.contact_relationships != nil {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.contact_fields != nil {
		edges = append(edges, contact.EdgeContactFields)
	}
	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.EdgeContactFields:
		ids := make([]ent.Value, 0, len(m.contact_fields))
		for id := range m.contact_fields {
			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, 3)
	if m.removedcontact_relationships != nil {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.removedcontact_fields != nil {
		edges = append(edges, contact.EdgeContactFields)
	}
	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.EdgeContactFields:
		ids := make([]ent.Value, 0, len(m.removedcontact_fields))
		for id := range m.removedcontact_fields {
			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, 3)
	if m.clearedcontact_relationships {
		edges = append(edges, contact.EdgeContactRelationships)
	}
	if m.clearedcontact_fields {
		edges = append(edges, contact.EdgeContactFields)
	}
	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.EdgeContactFields:
		return m.clearedcontact_fields
	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.EdgeContactFields:
		m.ResetContactFields()
		return nil
	case contact.EdgeContactMessages:
		m.ResetContactMessages()
		return nil
	}
	return fmt.Errorf("unknown Contact edge %s", name)
}

// ContactFieldMutation represents an operation that mutates the ContactField nodes in the graph.
type ContactFieldMutation struct {
	config
	op                   Op
	typ                  string
	id                   *uint64
	created_at           *time.Time
	updated_at           *time.Time
	status               *uint8
	addstatus            *int8
	deleted_at           *time.Time
	form_id              *string
	value                *[]string
	appendvalue          []string
	clearedFields        map[string]struct{}
	field_contact        *uint64
	clearedfield_contact bool
	done                 bool
	oldValue             func(context.Context) (*ContactField, error)
	predicates           []predicate.ContactField
}

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

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

// newContactFieldMutation creates new mutation for the ContactField entity.
func newContactFieldMutation(c config, op Op, opts ...contactfieldOption) *ContactFieldMutation {
	m := &ContactFieldMutation{
		config:        c,
		op:            op,
		typ:           TypeContactField,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *ContactFieldMutation) 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 ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) 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 *ContactFieldMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *ContactFieldMutation) 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 ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) 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 *ContactFieldMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *ContactFieldMutation) 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 ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) 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 *ContactFieldMutation) 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 *ContactFieldMutation) 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 *ContactFieldMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[contactfield.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *ContactFieldMutation) 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 ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) 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 *ContactFieldMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[contactfield.FieldDeletedAt] = struct{}{}
}

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

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

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

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

// OldContactID returns the old "contact_id" field's value of the ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) 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 *ContactFieldMutation) ResetContactID() {
	m.field_contact = nil
}

// SetFormID sets the "form_id" field.
func (m *ContactFieldMutation) SetFormID(s string) {
	m.form_id = &s
}

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

// OldFormID returns the old "form_id" field's value of the ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) OldFormID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldFormID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldFormID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldFormID: %w", err)
	}
	return oldValue.FormID, nil
}

// ResetFormID resets all changes to the "form_id" field.
func (m *ContactFieldMutation) ResetFormID() {
	m.form_id = nil
}

// SetValue sets the "value" field.
func (m *ContactFieldMutation) SetValue(s []string) {
	m.value = &s
	m.appendvalue = nil
}

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

// OldValue returns the old "value" field's value of the ContactField entity.
// If the ContactField object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldMutation) OldValue(ctx context.Context) (v []string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldValue is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldValue requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldValue: %w", err)
	}
	return oldValue.Value, nil
}

// AppendValue adds s to the "value" field.
func (m *ContactFieldMutation) AppendValue(s []string) {
	m.appendvalue = append(m.appendvalue, s...)
}

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

// ResetValue resets all changes to the "value" field.
func (m *ContactFieldMutation) ResetValue() {
	m.value = nil
	m.appendvalue = nil
}

// SetFieldContactID sets the "field_contact" edge to the Contact entity by id.
func (m *ContactFieldMutation) SetFieldContactID(id uint64) {
	m.field_contact = &id
}

// ClearFieldContact clears the "field_contact" edge to the Contact entity.
func (m *ContactFieldMutation) ClearFieldContact() {
	m.clearedfield_contact = true
	m.clearedFields[contactfield.FieldContactID] = struct{}{}
}

// FieldContactCleared reports if the "field_contact" edge to the Contact entity was cleared.
func (m *ContactFieldMutation) FieldContactCleared() bool {
	return m.clearedfield_contact
}

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

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

// ResetFieldContact resets all changes to the "field_contact" edge.
func (m *ContactFieldMutation) ResetFieldContact() {
	m.field_contact = nil
	m.clearedfield_contact = false
}

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

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

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

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

// Type returns the node type of this mutation (ContactField).
func (m *ContactFieldMutation) 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 *ContactFieldMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, contactfield.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, contactfield.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, contactfield.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, contactfield.FieldDeletedAt)
	}
	if m.field_contact != nil {
		fields = append(fields, contactfield.FieldContactID)
	}
	if m.form_id != nil {
		fields = append(fields, contactfield.FieldFormID)
	}
	if m.value != nil {
		fields = append(fields, contactfield.FieldValue)
	}
	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 *ContactFieldMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case contactfield.FieldCreatedAt:
		return m.CreatedAt()
	case contactfield.FieldUpdatedAt:
		return m.UpdatedAt()
	case contactfield.FieldStatus:
		return m.Status()
	case contactfield.FieldDeletedAt:
		return m.DeletedAt()
	case contactfield.FieldContactID:
		return m.ContactID()
	case contactfield.FieldFormID:
		return m.FormID()
	case contactfield.FieldValue:
		return m.Value()
	}
	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 *ContactFieldMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case contactfield.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case contactfield.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case contactfield.FieldStatus:
		return m.OldStatus(ctx)
	case contactfield.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case contactfield.FieldContactID:
		return m.OldContactID(ctx)
	case contactfield.FieldFormID:
		return m.OldFormID(ctx)
	case contactfield.FieldValue:
		return m.OldValue(ctx)
	}
	return nil, fmt.Errorf("unknown ContactField 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 *ContactFieldMutation) SetField(name string, value ent.Value) error {
	switch name {
	case contactfield.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 contactfield.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 contactfield.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case contactfield.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 contactfield.FieldContactID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetContactID(v)
		return nil
	case contactfield.FieldFormID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFormID(v)
		return nil
	case contactfield.FieldValue:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetValue(v)
		return nil
	}
	return fmt.Errorf("unknown ContactField field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ContactFieldMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, contactfield.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 *ContactFieldMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case contactfield.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 *ContactFieldMutation) AddField(name string, value ent.Value) error {
	switch name {
	case contactfield.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 ContactField numeric field %s", name)
}

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

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

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *ContactFieldMutation) EdgeCleared(name string) bool {
	switch name {
	case contactfield.EdgeFieldContact:
		return m.clearedfield_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 *ContactFieldMutation) ClearEdge(name string) error {
	switch name {
	case contactfield.EdgeFieldContact:
		m.ClearFieldContact()
		return nil
	}
	return fmt.Errorf("unknown ContactField 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 *ContactFieldMutation) ResetEdge(name string) error {
	switch name {
	case contactfield.EdgeFieldContact:
		m.ResetFieldContact()
		return nil
	}
	return fmt.Errorf("unknown ContactField edge %s", name)
}

// ContactFieldTemplateMutation represents an operation that mutates the ContactFieldTemplate nodes in the graph.
type ContactFieldTemplateMutation 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
	template           *[]custom_types.ContactFieldTemplate
	appendtemplate     []custom_types.ContactFieldTemplate
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*ContactFieldTemplate, error)
	predicates         []predicate.ContactFieldTemplate
}

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

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

// newContactFieldTemplateMutation creates new mutation for the ContactFieldTemplate entity.
func newContactFieldTemplateMutation(c config, op Op, opts ...contactfieldtemplateOption) *ContactFieldTemplateMutation {
	m := &ContactFieldTemplateMutation{
		config:        c,
		op:            op,
		typ:           TypeContactFieldTemplate,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *ContactFieldTemplateMutation) 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 ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *ContactFieldTemplateMutation) 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 ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *ContactFieldTemplateMutation) 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 ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[contactfieldtemplate.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *ContactFieldTemplateMutation) 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 ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[contactfieldtemplate.FieldDeletedAt] = struct{}{}
}

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) 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 ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

// SetTemplate sets the "template" field.
func (m *ContactFieldTemplateMutation) SetTemplate(ctft []custom_types.ContactFieldTemplate) {
	m.template = &ctft
	m.appendtemplate = nil
}

// Template returns the value of the "template" field in the mutation.
func (m *ContactFieldTemplateMutation) Template() (r []custom_types.ContactFieldTemplate, exists bool) {
	v := m.template
	if v == nil {
		return
	}
	return *v, true
}

// OldTemplate returns the old "template" field's value of the ContactFieldTemplate entity.
// If the ContactFieldTemplate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ContactFieldTemplateMutation) OldTemplate(ctx context.Context) (v []custom_types.ContactFieldTemplate, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTemplate is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTemplate requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTemplate: %w", err)
	}
	return oldValue.Template, nil
}

// AppendTemplate adds ctft to the "template" field.
func (m *ContactFieldTemplateMutation) AppendTemplate(ctft []custom_types.ContactFieldTemplate) {
	m.appendtemplate = append(m.appendtemplate, ctft...)
}

// AppendedTemplate returns the list of values that were appended to the "template" field in this mutation.
func (m *ContactFieldTemplateMutation) AppendedTemplate() ([]custom_types.ContactFieldTemplate, bool) {
	if len(m.appendtemplate) == 0 {
		return nil, false
	}
	return m.appendtemplate, true
}

// ResetTemplate resets all changes to the "template" field.
func (m *ContactFieldTemplateMutation) ResetTemplate() {
	m.template = nil
	m.appendtemplate = nil
}

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

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

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

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

// Type returns the node type of this mutation (ContactFieldTemplate).
func (m *ContactFieldTemplateMutation) 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 *ContactFieldTemplateMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.created_at != nil {
		fields = append(fields, contactfieldtemplate.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, contactfieldtemplate.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, contactfieldtemplate.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, contactfieldtemplate.FieldDeletedAt)
	}
	if m.organization_id != nil {
		fields = append(fields, contactfieldtemplate.FieldOrganizationID)
	}
	if m.template != nil {
		fields = append(fields, contactfieldtemplate.FieldTemplate)
	}
	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 *ContactFieldTemplateMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case contactfieldtemplate.FieldCreatedAt:
		return m.CreatedAt()
	case contactfieldtemplate.FieldUpdatedAt:
		return m.UpdatedAt()
	case contactfieldtemplate.FieldStatus:
		return m.Status()
	case contactfieldtemplate.FieldDeletedAt:
		return m.DeletedAt()
	case contactfieldtemplate.FieldOrganizationID:
		return m.OrganizationID()
	case contactfieldtemplate.FieldTemplate:
		return m.Template()
	}
	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 *ContactFieldTemplateMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case contactfieldtemplate.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case contactfieldtemplate.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case contactfieldtemplate.FieldStatus:
		return m.OldStatus(ctx)
	case contactfieldtemplate.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case contactfieldtemplate.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case contactfieldtemplate.FieldTemplate:
		return m.OldTemplate(ctx)
	}
	return nil, fmt.Errorf("unknown ContactFieldTemplate 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 *ContactFieldTemplateMutation) SetField(name string, value ent.Value) error {
	switch name {
	case contactfieldtemplate.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 contactfieldtemplate.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 contactfieldtemplate.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case contactfieldtemplate.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 contactfieldtemplate.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case contactfieldtemplate.FieldTemplate:
		v, ok := value.([]custom_types.ContactFieldTemplate)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTemplate(v)
		return nil
	}
	return fmt.Errorf("unknown ContactFieldTemplate field %s", name)
}

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

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

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

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

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

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

// CreditBalanceMutation represents an operation that mutates the CreditBalance nodes in the graph.
type CreditBalanceMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	user_id            *string
	balance            *float32
	addbalance         *float32
	status             *int
	addstatus          *int
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*CreditBalance, error)
	predicates         []predicate.CreditBalance
}

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

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

// newCreditBalanceMutation creates new mutation for the CreditBalance entity.
func newCreditBalanceMutation(c config, op Op, opts ...creditbalanceOption) *CreditBalanceMutation {
	m := &CreditBalanceMutation{
		config:        c,
		op:            op,
		typ:           TypeCreditBalance,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *CreditBalanceMutation) 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 CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *CreditBalanceMutation) 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 CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *CreditBalanceMutation) 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 CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[creditbalance.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *CreditBalanceMutation) SetUserID(s string) {
	m.user_id = &s
}

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

// OldUserID returns the old "user_id" field's value of the CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) OldUserID(ctx context.Context) (v string, 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
}

// ClearUserID clears the value of the "user_id" field.
func (m *CreditBalanceMutation) ClearUserID() {
	m.user_id = nil
	m.clearedFields[creditbalance.FieldUserID] = struct{}{}
}

// UserIDCleared returns if the "user_id" field was cleared in this mutation.
func (m *CreditBalanceMutation) UserIDCleared() bool {
	_, ok := m.clearedFields[creditbalance.FieldUserID]
	return ok
}

// ResetUserID resets all changes to the "user_id" field.
func (m *CreditBalanceMutation) ResetUserID() {
	m.user_id = nil
	delete(m.clearedFields, creditbalance.FieldUserID)
}

// SetBalance sets the "balance" field.
func (m *CreditBalanceMutation) SetBalance(f float32) {
	m.balance = &f
	m.addbalance = nil
}

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

// OldBalance returns the old "balance" field's value of the CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) OldBalance(ctx context.Context) (v float32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBalance is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBalance requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBalance: %w", err)
	}
	return oldValue.Balance, nil
}

// AddBalance adds f to the "balance" field.
func (m *CreditBalanceMutation) AddBalance(f float32) {
	if m.addbalance != nil {
		*m.addbalance += f
	} else {
		m.addbalance = &f
	}
}

// AddedBalance returns the value that was added to the "balance" field in this mutation.
func (m *CreditBalanceMutation) AddedBalance() (r float32, exists bool) {
	v := m.addbalance
	if v == nil {
		return
	}
	return *v, true
}

// ResetBalance resets all changes to the "balance" field.
func (m *CreditBalanceMutation) ResetBalance() {
	m.balance = nil
	m.addbalance = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *CreditBalanceMutation) 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 CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) 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 *CreditBalanceMutation) 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 *CreditBalanceMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[creditbalance.FieldStatus] = struct{}{}
}

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) 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 CreditBalance entity.
// If the CreditBalance object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) 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 *CreditBalanceMutation) 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 *CreditBalanceMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[creditbalance.FieldOrganizationID] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (CreditBalance).
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, creditbalance.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, creditbalance.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, creditbalance.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, creditbalance.FieldUserID)
	}
	if m.balance != nil {
		fields = append(fields, creditbalance.FieldBalance)
	}
	if m.status != nil {
		fields = append(fields, creditbalance.FieldStatus)
	}
	if m.organization_id != nil {
		fields = append(fields, creditbalance.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 *CreditBalanceMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case creditbalance.FieldCreatedAt:
		return m.CreatedAt()
	case creditbalance.FieldUpdatedAt:
		return m.UpdatedAt()
	case creditbalance.FieldDeletedAt:
		return m.DeletedAt()
	case creditbalance.FieldUserID:
		return m.UserID()
	case creditbalance.FieldBalance:
		return m.Balance()
	case creditbalance.FieldStatus:
		return m.Status()
	case creditbalance.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 *CreditBalanceMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case creditbalance.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case creditbalance.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case creditbalance.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case creditbalance.FieldUserID:
		return m.OldUserID(ctx)
	case creditbalance.FieldBalance:
		return m.OldBalance(ctx)
	case creditbalance.FieldStatus:
		return m.OldStatus(ctx)
	case creditbalance.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown CreditBalance 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 *CreditBalanceMutation) SetField(name string, value ent.Value) error {
	switch name {
	case creditbalance.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 creditbalance.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 creditbalance.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 creditbalance.FieldUserID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case creditbalance.FieldBalance:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBalance(v)
		return nil
	case creditbalance.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case creditbalance.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 CreditBalance field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CreditBalanceMutation) 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 *CreditBalanceMutation) ClearField(name string) error {
	switch name {
	case creditbalance.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case creditbalance.FieldUserID:
		m.ClearUserID()
		return nil
	case creditbalance.FieldStatus:
		m.ClearStatus()
		return nil
	case creditbalance.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown CreditBalance 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 *CreditBalanceMutation) ResetField(name string) error {
	switch name {
	case creditbalance.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case creditbalance.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case creditbalance.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case creditbalance.FieldUserID:
		m.ResetUserID()
		return nil
	case creditbalance.FieldBalance:
		m.ResetBalance()
		return nil
	case creditbalance.FieldStatus:
		m.ResetStatus()
		return nil
	case creditbalance.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown CreditBalance field %s", name)
}

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

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

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

// CreditUsageMutation represents an operation that mutates the CreditUsage nodes in the graph.
type CreditUsageMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	user_id            *string
	number             *float32
	addnumber          *float32
	status             *int
	addstatus          *int
	ntype              *int
	addntype           *int
	table              *string
	organization_id    *uint64
	addorganization_id *int64
	nid                *uint64
	addnid             *int64
	reason             *string
	operator           *string
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*CreditUsage, error)
	predicates         []predicate.CreditUsage
}

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

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

// newCreditUsageMutation creates new mutation for the CreditUsage entity.
func newCreditUsageMutation(c config, op Op, opts ...creditusageOption) *CreditUsageMutation {
	m := &CreditUsageMutation{
		config:        c,
		op:            op,
		typ:           TypeCreditUsage,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *CreditUsageMutation) 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 CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *CreditUsageMutation) 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 CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *CreditUsageMutation) 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 CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[creditusage.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *CreditUsageMutation) SetUserID(s string) {
	m.user_id = &s
}

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

// OldUserID returns the old "user_id" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldUserID(ctx context.Context) (v string, 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
}

// ClearUserID clears the value of the "user_id" field.
func (m *CreditUsageMutation) ClearUserID() {
	m.user_id = nil
	m.clearedFields[creditusage.FieldUserID] = struct{}{}
}

// UserIDCleared returns if the "user_id" field was cleared in this mutation.
func (m *CreditUsageMutation) UserIDCleared() bool {
	_, ok := m.clearedFields[creditusage.FieldUserID]
	return ok
}

// ResetUserID resets all changes to the "user_id" field.
func (m *CreditUsageMutation) ResetUserID() {
	m.user_id = nil
	delete(m.clearedFields, creditusage.FieldUserID)
}

// SetNumber sets the "number" field.
func (m *CreditUsageMutation) SetNumber(f float32) {
	m.number = &f
	m.addnumber = nil
}

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

// OldNumber returns the old "number" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldNumber(ctx context.Context) (v float32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNumber is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNumber requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNumber: %w", err)
	}
	return oldValue.Number, nil
}

// AddNumber adds f to the "number" field.
func (m *CreditUsageMutation) AddNumber(f float32) {
	if m.addnumber != nil {
		*m.addnumber += f
	} else {
		m.addnumber = &f
	}
}

// AddedNumber returns the value that was added to the "number" field in this mutation.
func (m *CreditUsageMutation) AddedNumber() (r float32, exists bool) {
	v := m.addnumber
	if v == nil {
		return
	}
	return *v, true
}

// ResetNumber resets all changes to the "number" field.
func (m *CreditUsageMutation) ResetNumber() {
	m.number = nil
	m.addnumber = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *CreditUsageMutation) 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 CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) 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 *CreditUsageMutation) 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 *CreditUsageMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[creditusage.FieldStatus] = struct{}{}
}

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

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

// SetNtype sets the "ntype" field.
func (m *CreditUsageMutation) SetNtype(i int) {
	m.ntype = &i
	m.addntype = nil
}

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

// OldNtype returns the old "ntype" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldNtype(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNtype is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNtype requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNtype: %w", err)
	}
	return oldValue.Ntype, nil
}

// AddNtype adds i to the "ntype" field.
func (m *CreditUsageMutation) AddNtype(i int) {
	if m.addntype != nil {
		*m.addntype += i
	} else {
		m.addntype = &i
	}
}

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

// ResetNtype resets all changes to the "ntype" field.
func (m *CreditUsageMutation) ResetNtype() {
	m.ntype = nil
	m.addntype = nil
}

// SetTable sets the "table" field.
func (m *CreditUsageMutation) SetTable(s string) {
	m.table = &s
}

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

// OldTable returns the old "table" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldTable(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTable is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTable requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTable: %w", err)
	}
	return oldValue.Table, nil
}

// ResetTable resets all changes to the "table" field.
func (m *CreditUsageMutation) ResetTable() {
	m.table = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) 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 CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) 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 *CreditUsageMutation) 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 *CreditUsageMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[creditusage.FieldOrganizationID] = struct{}{}
}

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

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

// SetNid sets the "nid" field.
func (m *CreditUsageMutation) SetNid(u uint64) {
	m.nid = &u
	m.addnid = nil
}

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

// OldNid returns the old "nid" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldNid(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNid is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNid requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNid: %w", err)
	}
	return oldValue.Nid, nil
}

// AddNid adds u to the "nid" field.
func (m *CreditUsageMutation) AddNid(u int64) {
	if m.addnid != nil {
		*m.addnid += u
	} else {
		m.addnid = &u
	}
}

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

// ResetNid resets all changes to the "nid" field.
func (m *CreditUsageMutation) ResetNid() {
	m.nid = nil
	m.addnid = nil
}

// SetReason sets the "reason" field.
func (m *CreditUsageMutation) SetReason(s string) {
	m.reason = &s
}

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

// OldReason returns the old "reason" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldReason(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldReason is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldReason requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldReason: %w", err)
	}
	return oldValue.Reason, nil
}

// ResetReason resets all changes to the "reason" field.
func (m *CreditUsageMutation) ResetReason() {
	m.reason = nil
}

// SetOperator sets the "operator" field.
func (m *CreditUsageMutation) SetOperator(s string) {
	m.operator = &s
}

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

// OldOperator returns the old "operator" field's value of the CreditUsage entity.
// If the CreditUsage object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CreditUsageMutation) OldOperator(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOperator is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOperator requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOperator: %w", err)
	}
	return oldValue.Operator, nil
}

// ResetOperator resets all changes to the "operator" field.
func (m *CreditUsageMutation) ResetOperator() {
	m.operator = nil
}

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

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

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

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

// Type returns the node type of this mutation (CreditUsage).
func (m *CreditUsageMutation) 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 *CreditUsageMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, creditusage.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, creditusage.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, creditusage.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, creditusage.FieldUserID)
	}
	if m.number != nil {
		fields = append(fields, creditusage.FieldNumber)
	}
	if m.status != nil {
		fields = append(fields, creditusage.FieldStatus)
	}
	if m.ntype != nil {
		fields = append(fields, creditusage.FieldNtype)
	}
	if m.table != nil {
		fields = append(fields, creditusage.FieldTable)
	}
	if m.organization_id != nil {
		fields = append(fields, creditusage.FieldOrganizationID)
	}
	if m.nid != nil {
		fields = append(fields, creditusage.FieldNid)
	}
	if m.reason != nil {
		fields = append(fields, creditusage.FieldReason)
	}
	if m.operator != nil {
		fields = append(fields, creditusage.FieldOperator)
	}
	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 *CreditUsageMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case creditusage.FieldCreatedAt:
		return m.CreatedAt()
	case creditusage.FieldUpdatedAt:
		return m.UpdatedAt()
	case creditusage.FieldDeletedAt:
		return m.DeletedAt()
	case creditusage.FieldUserID:
		return m.UserID()
	case creditusage.FieldNumber:
		return m.Number()
	case creditusage.FieldStatus:
		return m.Status()
	case creditusage.FieldNtype:
		return m.Ntype()
	case creditusage.FieldTable:
		return m.Table()
	case creditusage.FieldOrganizationID:
		return m.OrganizationID()
	case creditusage.FieldNid:
		return m.Nid()
	case creditusage.FieldReason:
		return m.Reason()
	case creditusage.FieldOperator:
		return m.Operator()
	}
	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 *CreditUsageMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case creditusage.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case creditusage.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case creditusage.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case creditusage.FieldUserID:
		return m.OldUserID(ctx)
	case creditusage.FieldNumber:
		return m.OldNumber(ctx)
	case creditusage.FieldStatus:
		return m.OldStatus(ctx)
	case creditusage.FieldNtype:
		return m.OldNtype(ctx)
	case creditusage.FieldTable:
		return m.OldTable(ctx)
	case creditusage.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case creditusage.FieldNid:
		return m.OldNid(ctx)
	case creditusage.FieldReason:
		return m.OldReason(ctx)
	case creditusage.FieldOperator:
		return m.OldOperator(ctx)
	}
	return nil, fmt.Errorf("unknown CreditUsage 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 *CreditUsageMutation) SetField(name string, value ent.Value) error {
	switch name {
	case creditusage.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 creditusage.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 creditusage.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 creditusage.FieldUserID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case creditusage.FieldNumber:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNumber(v)
		return nil
	case creditusage.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case creditusage.FieldNtype:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNtype(v)
		return nil
	case creditusage.FieldTable:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTable(v)
		return nil
	case creditusage.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case creditusage.FieldNid:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNid(v)
		return nil
	case creditusage.FieldReason:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReason(v)
		return nil
	case creditusage.FieldOperator:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOperator(v)
		return nil
	}
	return fmt.Errorf("unknown CreditUsage field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CreditUsageMutation) AddedFields() []string {
	var fields []string
	if m.addnumber != nil {
		fields = append(fields, creditusage.FieldNumber)
	}
	if m.addstatus != nil {
		fields = append(fields, creditusage.FieldStatus)
	}
	if m.addntype != nil {
		fields = append(fields, creditusage.FieldNtype)
	}
	if m.addorganization_id != nil {
		fields = append(fields, creditusage.FieldOrganizationID)
	}
	if m.addnid != nil {
		fields = append(fields, creditusage.FieldNid)
	}
	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 *CreditUsageMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case creditusage.FieldNumber:
		return m.AddedNumber()
	case creditusage.FieldStatus:
		return m.AddedStatus()
	case creditusage.FieldNtype:
		return m.AddedNtype()
	case creditusage.FieldOrganizationID:
		return m.AddedOrganizationID()
	case creditusage.FieldNid:
		return m.AddedNid()
	}
	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 *CreditUsageMutation) AddField(name string, value ent.Value) error {
	switch name {
	case creditusage.FieldNumber:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNumber(v)
		return nil
	case creditusage.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case creditusage.FieldNtype:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNtype(v)
		return nil
	case creditusage.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case creditusage.FieldNid:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNid(v)
		return nil
	}
	return fmt.Errorf("unknown CreditUsage numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CreditUsageMutation) 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 *CreditUsageMutation) ClearField(name string) error {
	switch name {
	case creditusage.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case creditusage.FieldUserID:
		m.ClearUserID()
		return nil
	case creditusage.FieldStatus:
		m.ClearStatus()
		return nil
	case creditusage.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown CreditUsage 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 *CreditUsageMutation) ResetField(name string) error {
	switch name {
	case creditusage.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case creditusage.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case creditusage.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case creditusage.FieldUserID:
		m.ResetUserID()
		return nil
	case creditusage.FieldNumber:
		m.ResetNumber()
		return nil
	case creditusage.FieldStatus:
		m.ResetStatus()
		return nil
	case creditusage.FieldNtype:
		m.ResetNtype()
		return nil
	case creditusage.FieldTable:
		m.ResetTable()
		return nil
	case creditusage.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case creditusage.FieldNid:
		m.ResetNid()
		return nil
	case creditusage.FieldReason:
		m.ResetReason()
		return nil
	case creditusage.FieldOperator:
		m.ResetOperator()
		return nil
	}
	return fmt.Errorf("unknown CreditUsage field %s", name)
}

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

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

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

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

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

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

// ResetChatURL resets all changes to the "chat_url" field.
func (m *EmployeeMutation) ResetChatURL() {
	m.chat_url = 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, 23)
	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)
	}
	if m.chat_url != nil {
		fields = append(fields, employee.FieldChatURL)
	}
	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()
	case employee.FieldChatURL:
		return m.ChatURL()
	}
	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)
	case employee.FieldChatURL:
		return m.OldChatURL(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
	case employee.FieldChatURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChatURL(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
	case employee.FieldChatURL:
		m.ResetChatURL()
		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
	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)
}

// 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, 6)
	if m.created_at != nil {
		fields = append(fields, labelrelationship.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, labelrelationship.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, labelrelationship.FieldStatus)
	}
	if m.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.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.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.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.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.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.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)
}

// LabelTaggingMutation represents an operation that mutates the LabelTagging nodes in the graph.
type LabelTaggingMutation 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
	_type                  *int
	add_type               *int
	conditions             *string
	action_label_add       *[]uint64
	appendaction_label_add []uint64
	action_label_del       *[]uint64
	appendaction_label_del []uint64
	clearedFields          map[string]struct{}
	done                   bool
	oldValue               func(context.Context) (*LabelTagging, error)
	predicates             []predicate.LabelTagging
}

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

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

// newLabelTaggingMutation creates new mutation for the LabelTagging entity.
func newLabelTaggingMutation(c config, op Op, opts ...labeltaggingOption) *LabelTaggingMutation {
	m := &LabelTaggingMutation{
		config:        c,
		op:            op,
		typ:           TypeLabelTagging,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[labeltagging.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[labeltagging.FieldDeletedAt] = struct{}{}
}

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

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

// GetType returns the value of the "type" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) ResetType() {
	m._type = nil
	m.add_type = nil
}

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

// Conditions returns the value of the "conditions" field in the mutation.
func (m *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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
}

// ResetConditions resets all changes to the "conditions" field.
func (m *LabelTaggingMutation) ResetConditions() {
	m.conditions = nil
}

// SetActionLabelAdd sets the "action_label_add" field.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) ClearActionLabelAdd() {
	m.action_label_add = nil
	m.appendaction_label_add = nil
	m.clearedFields[labeltagging.FieldActionLabelAdd] = struct{}{}
}

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

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

// SetActionLabelDel sets the "action_label_del" field.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 LabelTagging entity.
// If the LabelTagging object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) 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 *LabelTaggingMutation) ClearActionLabelDel() {
	m.action_label_del = nil
	m.appendaction_label_del = nil
	m.clearedFields[labeltagging.FieldActionLabelDel] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (LabelTagging).
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, labeltagging.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, labeltagging.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, labeltagging.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, labeltagging.FieldDeletedAt)
	}
	if m.organization_id != nil {
		fields = append(fields, labeltagging.FieldOrganizationID)
	}
	if m._type != nil {
		fields = append(fields, labeltagging.FieldType)
	}
	if m.conditions != nil {
		fields = append(fields, labeltagging.FieldConditions)
	}
	if m.action_label_add != nil {
		fields = append(fields, labeltagging.FieldActionLabelAdd)
	}
	if m.action_label_del != nil {
		fields = append(fields, labeltagging.FieldActionLabelDel)
	}
	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 *LabelTaggingMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case labeltagging.FieldCreatedAt:
		return m.CreatedAt()
	case labeltagging.FieldUpdatedAt:
		return m.UpdatedAt()
	case labeltagging.FieldStatus:
		return m.Status()
	case labeltagging.FieldDeletedAt:
		return m.DeletedAt()
	case labeltagging.FieldOrganizationID:
		return m.OrganizationID()
	case labeltagging.FieldType:
		return m.GetType()
	case labeltagging.FieldConditions:
		return m.Conditions()
	case labeltagging.FieldActionLabelAdd:
		return m.ActionLabelAdd()
	case labeltagging.FieldActionLabelDel:
		return m.ActionLabelDel()
	}
	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 *LabelTaggingMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case labeltagging.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case labeltagging.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case labeltagging.FieldStatus:
		return m.OldStatus(ctx)
	case labeltagging.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case labeltagging.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case labeltagging.FieldType:
		return m.OldType(ctx)
	case labeltagging.FieldConditions:
		return m.OldConditions(ctx)
	case labeltagging.FieldActionLabelAdd:
		return m.OldActionLabelAdd(ctx)
	case labeltagging.FieldActionLabelDel:
		return m.OldActionLabelDel(ctx)
	}
	return nil, fmt.Errorf("unknown LabelTagging 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 *LabelTaggingMutation) SetField(name string, value ent.Value) error {
	switch name {
	case labeltagging.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 labeltagging.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 labeltagging.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case labeltagging.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 labeltagging.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case labeltagging.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case labeltagging.FieldConditions:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConditions(v)
		return nil
	case labeltagging.FieldActionLabelAdd:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelAdd(v)
		return nil
	case labeltagging.FieldActionLabelDel:
		v, ok := value.([]uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActionLabelDel(v)
		return nil
	}
	return fmt.Errorf("unknown LabelTagging field %s", name)
}

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

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

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *LabelTaggingMutation) 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 *LabelTaggingMutation) ClearField(name string) error {
	switch name {
	case labeltagging.FieldStatus:
		m.ClearStatus()
		return nil
	case labeltagging.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case labeltagging.FieldActionLabelAdd:
		m.ClearActionLabelAdd()
		return nil
	case labeltagging.FieldActionLabelDel:
		m.ClearActionLabelDel()
		return nil
	}
	return fmt.Errorf("unknown LabelTagging 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 *LabelTaggingMutation) ResetField(name string) error {
	switch name {
	case labeltagging.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case labeltagging.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case labeltagging.FieldStatus:
		m.ResetStatus()
		return nil
	case labeltagging.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case labeltagging.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case labeltagging.FieldType:
		m.ResetType()
		return nil
	case labeltagging.FieldConditions:
		m.ResetConditions()
		return nil
	case labeltagging.FieldActionLabelAdd:
		m.ResetActionLabelAdd()
		return nil
	case labeltagging.FieldActionLabelDel:
		m.ResetActionLabelDel()
		return nil
	}
	return fmt.Errorf("unknown LabelTagging field %s", name)
}

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

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

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

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

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

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

// ResetCc resets all changes to the "cc" field.
func (m *MsgMutation) ResetCc() {
	m.cc = nil
}

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

// Phone returns the value of the "phone" field in the mutation.
func (m *MsgMutation) 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 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) 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 *MsgMutation) ResetPhone() {
	m.phone = nil
}

// 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, 11)
	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)
	}
	if m.cc != nil {
		fields = append(fields, msg.FieldCc)
	}
	if m.phone != nil {
		fields = append(fields, msg.FieldPhone)
	}
	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()
	case msg.FieldCc:
		return m.Cc()
	case msg.FieldPhone:
		return m.Phone()
	}
	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)
	case msg.FieldCc:
		return m.OldCc(ctx)
	case msg.FieldPhone:
		return m.OldPhone(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
	case msg.FieldCc:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCc(v)
		return nil
	case msg.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(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
	case msg.FieldCc:
		m.ResetCc()
		return nil
	case msg.FieldPhone:
		m.ResetPhone()
		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)
}

// PayRechargeMutation represents an operation that mutates the PayRecharge nodes in the graph.
type PayRechargeMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	deleted_at         *time.Time
	user_id            *string
	number             *float32
	addnumber          *float32
	status             *int
	addstatus          *int
	money              *float32
	addmoney           *float32
	out_trade_no       *string
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*PayRecharge, error)
	predicates         []predicate.PayRecharge
}

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

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

// newPayRechargeMutation creates new mutation for the PayRecharge entity.
func newPayRechargeMutation(c config, op Op, opts ...payrechargeOption) *PayRechargeMutation {
	m := &PayRechargeMutation{
		config:        c,
		op:            op,
		typ:           TypePayRecharge,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *PayRechargeMutation) 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 PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *PayRechargeMutation) 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 PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *PayRechargeMutation) 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 PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[payrecharge.FieldDeletedAt] = struct{}{}
}

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

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

// SetUserID sets the "user_id" field.
func (m *PayRechargeMutation) SetUserID(s string) {
	m.user_id = &s
}

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

// OldUserID returns the old "user_id" field's value of the PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) OldUserID(ctx context.Context) (v string, 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
}

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

// SetNumber sets the "number" field.
func (m *PayRechargeMutation) SetNumber(f float32) {
	m.number = &f
	m.addnumber = nil
}

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

// OldNumber returns the old "number" field's value of the PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) OldNumber(ctx context.Context) (v float32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNumber is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNumber requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNumber: %w", err)
	}
	return oldValue.Number, nil
}

// AddNumber adds f to the "number" field.
func (m *PayRechargeMutation) AddNumber(f float32) {
	if m.addnumber != nil {
		*m.addnumber += f
	} else {
		m.addnumber = &f
	}
}

// AddedNumber returns the value that was added to the "number" field in this mutation.
func (m *PayRechargeMutation) AddedNumber() (r float32, exists bool) {
	v := m.addnumber
	if v == nil {
		return
	}
	return *v, true
}

// ResetNumber resets all changes to the "number" field.
func (m *PayRechargeMutation) ResetNumber() {
	m.number = nil
	m.addnumber = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *PayRechargeMutation) 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 PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) 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 *PayRechargeMutation) 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 *PayRechargeMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[payrecharge.FieldStatus] = struct{}{}
}

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

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

// SetMoney sets the "money" field.
func (m *PayRechargeMutation) SetMoney(f float32) {
	m.money = &f
	m.addmoney = nil
}

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

// OldMoney returns the old "money" field's value of the PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) OldMoney(ctx context.Context) (v float32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldMoney is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldMoney requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMoney: %w", err)
	}
	return oldValue.Money, nil
}

// AddMoney adds f to the "money" field.
func (m *PayRechargeMutation) AddMoney(f float32) {
	if m.addmoney != nil {
		*m.addmoney += f
	} else {
		m.addmoney = &f
	}
}

// AddedMoney returns the value that was added to the "money" field in this mutation.
func (m *PayRechargeMutation) AddedMoney() (r float32, exists bool) {
	v := m.addmoney
	if v == nil {
		return
	}
	return *v, true
}

// ClearMoney clears the value of the "money" field.
func (m *PayRechargeMutation) ClearMoney() {
	m.money = nil
	m.addmoney = nil
	m.clearedFields[payrecharge.FieldMoney] = struct{}{}
}

// MoneyCleared returns if the "money" field was cleared in this mutation.
func (m *PayRechargeMutation) MoneyCleared() bool {
	_, ok := m.clearedFields[payrecharge.FieldMoney]
	return ok
}

// ResetMoney resets all changes to the "money" field.
func (m *PayRechargeMutation) ResetMoney() {
	m.money = nil
	m.addmoney = nil
	delete(m.clearedFields, payrecharge.FieldMoney)
}

// SetOutTradeNo sets the "out_trade_no" field.
func (m *PayRechargeMutation) SetOutTradeNo(s string) {
	m.out_trade_no = &s
}

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

// OldOutTradeNo returns the old "out_trade_no" field's value of the PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) OldOutTradeNo(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOutTradeNo is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOutTradeNo requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOutTradeNo: %w", err)
	}
	return oldValue.OutTradeNo, nil
}

// ClearOutTradeNo clears the value of the "out_trade_no" field.
func (m *PayRechargeMutation) ClearOutTradeNo() {
	m.out_trade_no = nil
	m.clearedFields[payrecharge.FieldOutTradeNo] = struct{}{}
}

// OutTradeNoCleared returns if the "out_trade_no" field was cleared in this mutation.
func (m *PayRechargeMutation) OutTradeNoCleared() bool {
	_, ok := m.clearedFields[payrecharge.FieldOutTradeNo]
	return ok
}

// ResetOutTradeNo resets all changes to the "out_trade_no" field.
func (m *PayRechargeMutation) ResetOutTradeNo() {
	m.out_trade_no = nil
	delete(m.clearedFields, payrecharge.FieldOutTradeNo)
}

// SetOrganizationID sets the "organization_id" field.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) 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 PayRecharge entity.
// If the PayRecharge object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) 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 *PayRechargeMutation) 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 *PayRechargeMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

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

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

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

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

// Type returns the node type of this mutation (PayRecharge).
func (m *PayRechargeMutation) 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 *PayRechargeMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, payrecharge.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, payrecharge.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, payrecharge.FieldDeletedAt)
	}
	if m.user_id != nil {
		fields = append(fields, payrecharge.FieldUserID)
	}
	if m.number != nil {
		fields = append(fields, payrecharge.FieldNumber)
	}
	if m.status != nil {
		fields = append(fields, payrecharge.FieldStatus)
	}
	if m.money != nil {
		fields = append(fields, payrecharge.FieldMoney)
	}
	if m.out_trade_no != nil {
		fields = append(fields, payrecharge.FieldOutTradeNo)
	}
	if m.organization_id != nil {
		fields = append(fields, payrecharge.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 *PayRechargeMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case payrecharge.FieldCreatedAt:
		return m.CreatedAt()
	case payrecharge.FieldUpdatedAt:
		return m.UpdatedAt()
	case payrecharge.FieldDeletedAt:
		return m.DeletedAt()
	case payrecharge.FieldUserID:
		return m.UserID()
	case payrecharge.FieldNumber:
		return m.Number()
	case payrecharge.FieldStatus:
		return m.Status()
	case payrecharge.FieldMoney:
		return m.Money()
	case payrecharge.FieldOutTradeNo:
		return m.OutTradeNo()
	case payrecharge.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 *PayRechargeMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case payrecharge.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case payrecharge.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case payrecharge.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case payrecharge.FieldUserID:
		return m.OldUserID(ctx)
	case payrecharge.FieldNumber:
		return m.OldNumber(ctx)
	case payrecharge.FieldStatus:
		return m.OldStatus(ctx)
	case payrecharge.FieldMoney:
		return m.OldMoney(ctx)
	case payrecharge.FieldOutTradeNo:
		return m.OldOutTradeNo(ctx)
	case payrecharge.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown PayRecharge 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 *PayRechargeMutation) SetField(name string, value ent.Value) error {
	switch name {
	case payrecharge.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 payrecharge.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 payrecharge.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 payrecharge.FieldUserID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUserID(v)
		return nil
	case payrecharge.FieldNumber:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNumber(v)
		return nil
	case payrecharge.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case payrecharge.FieldMoney:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMoney(v)
		return nil
	case payrecharge.FieldOutTradeNo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOutTradeNo(v)
		return nil
	case payrecharge.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 PayRecharge field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *PayRechargeMutation) AddedFields() []string {
	var fields []string
	if m.addnumber != nil {
		fields = append(fields, payrecharge.FieldNumber)
	}
	if m.addstatus != nil {
		fields = append(fields, payrecharge.FieldStatus)
	}
	if m.addmoney != nil {
		fields = append(fields, payrecharge.FieldMoney)
	}
	if m.addorganization_id != nil {
		fields = append(fields, payrecharge.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 *PayRechargeMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case payrecharge.FieldNumber:
		return m.AddedNumber()
	case payrecharge.FieldStatus:
		return m.AddedStatus()
	case payrecharge.FieldMoney:
		return m.AddedMoney()
	case payrecharge.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 *PayRechargeMutation) AddField(name string, value ent.Value) error {
	switch name {
	case payrecharge.FieldNumber:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNumber(v)
		return nil
	case payrecharge.FieldStatus:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case payrecharge.FieldMoney:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddMoney(v)
		return nil
	case payrecharge.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 PayRecharge numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) ClearField(name string) error {
	switch name {
	case payrecharge.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case payrecharge.FieldStatus:
		m.ClearStatus()
		return nil
	case payrecharge.FieldMoney:
		m.ClearMoney()
		return nil
	case payrecharge.FieldOutTradeNo:
		m.ClearOutTradeNo()
		return nil
	}
	return fmt.Errorf("unknown PayRecharge 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 *PayRechargeMutation) ResetField(name string) error {
	switch name {
	case payrecharge.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case payrecharge.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case payrecharge.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case payrecharge.FieldUserID:
		m.ResetUserID()
		return nil
	case payrecharge.FieldNumber:
		m.ResetNumber()
		return nil
	case payrecharge.FieldStatus:
		m.ResetStatus()
		return nil
	case payrecharge.FieldMoney:
		m.ResetMoney()
		return nil
	case payrecharge.FieldOutTradeNo:
		m.ResetOutTradeNo()
		return nil
	case payrecharge.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown PayRecharge field %s", name)
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *PayRechargeMutation) 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 *PayRechargeMutation) 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 *PayRechargeMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown PayRecharge 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 *PayRechargeMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown PayRecharge 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
	token               *[]string
	appendtoken         []string
	clearedFields       map[string]struct{}
	task_stages         map[uint64]struct{}
	removedtask_stages  map[uint64]struct{}
	clearedtask_stages  bool
	done                bool
	oldValue            func(context.Context) (*SopTask, error)
	predicates          []predicate.SopTask
}

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

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

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

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

// withSopTask sets the old SopTask of the mutation.
func withSopTask(node *SopTask) soptaskOption {
	return func(m *SopTaskMutation) {
		m.oldValue = func(context.Context) (*SopTask, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m SopTaskMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m SopTaskMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

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

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

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

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

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

// OldCreatedAt returns the old "created_at" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

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

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

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

// OldUpdatedAt returns the old "updated_at" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
	}
	return oldValue.UpdatedAt, nil
}

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

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

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

// OldStatus returns the old "status" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldStatus(ctx context.Context) (v uint8, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStatus is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStatus requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
	}
	return oldValue.Status, nil
}

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

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

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

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

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

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

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

// OldDeletedAt returns the old "deleted_at" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldDeletedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
	}
	return oldValue.DeletedAt, nil
}

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

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

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

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

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

// OldName returns the old "name" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldName: %w", err)
	}
	return oldValue.Name, nil
}

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

// SetBotWxidList sets the "bot_wxid_list" field.
func (m *SopTaskMutation) SetBotWxidList(s []string) {
	m.bot_wxid_list = &s
	m.appendbot_wxid_list = nil
}

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

// OldBotWxidList returns the old "bot_wxid_list" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldBotWxidList(ctx context.Context) (v []string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBotWxidList is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBotWxidList requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBotWxidList: %w", err)
	}
	return oldValue.BotWxidList, nil
}

// AppendBotWxidList adds s to the "bot_wxid_list" field.
func (m *SopTaskMutation) AppendBotWxidList(s []string) {
	m.appendbot_wxid_list = append(m.appendbot_wxid_list, s...)
}

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

// ClearBotWxidList clears the value of the "bot_wxid_list" field.
func (m *SopTaskMutation) ClearBotWxidList() {
	m.bot_wxid_list = nil
	m.appendbot_wxid_list = nil
	m.clearedFields[soptask.FieldBotWxidList] = struct{}{}
}

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

// ResetBotWxidList resets all changes to the "bot_wxid_list" field.
func (m *SopTaskMutation) ResetBotWxidList() {
	m.bot_wxid_list = nil
	m.appendbot_wxid_list = nil
	delete(m.clearedFields, soptask.FieldBotWxidList)
}

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

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

// OldType returns the old "type" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldType(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldType is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldType requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldType: %w", err)
	}
	return oldValue.Type, nil
}

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

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

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

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

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

// OldPlanStartTime returns the old "plan_start_time" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldPlanStartTime(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPlanStartTime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPlanStartTime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPlanStartTime: %w", err)
	}
	return oldValue.PlanStartTime, nil
}

// ClearPlanStartTime clears the value of the "plan_start_time" field.
func (m *SopTaskMutation) ClearPlanStartTime() {
	m.plan_start_time = nil
	m.clearedFields[soptask.FieldPlanStartTime] = struct{}{}
}

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

// ResetPlanStartTime resets all changes to the "plan_start_time" field.
func (m *SopTaskMutation) ResetPlanStartTime() {
	m.plan_start_time = nil
	delete(m.clearedFields, soptask.FieldPlanStartTime)
}

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

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

// OldPlanEndTime returns the old "plan_end_time" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldPlanEndTime(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPlanEndTime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPlanEndTime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPlanEndTime: %w", err)
	}
	return oldValue.PlanEndTime, nil
}

// ClearPlanEndTime clears the value of the "plan_end_time" field.
func (m *SopTaskMutation) ClearPlanEndTime() {
	m.plan_end_time = nil
	m.clearedFields[soptask.FieldPlanEndTime] = struct{}{}
}

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

// ResetPlanEndTime resets all changes to the "plan_end_time" field.
func (m *SopTaskMutation) ResetPlanEndTime() {
	m.plan_end_time = nil
	delete(m.clearedFields, soptask.FieldPlanEndTime)
}

// SetCreatorID sets the "creator_id" field.
func (m *SopTaskMutation) SetCreatorID(s string) {
	m.creator_id = &s
}

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

// OldCreatorID returns the old "creator_id" field's value of the SopTask entity.
// If the SopTask object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *SopTaskMutation) OldCreatorID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatorID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCreatorID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatorID: %w", err)
	}
	return oldValue.CreatorID, nil
}

// ClearCreatorID clears the value of the "creator_id" field.
func (m *SopTaskMutation) ClearCreatorID() {
	m.creator_id = nil
	m.clearedFields[soptask.FieldCreatorID] = struct{}{}
}

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

// ResetCreatorID resets all changes to the "creator_id" field.
func (m *SopTaskMutation) ResetCreatorID() {
	m.creator_id = nil
	delete(m.clearedFields, soptask.FieldCreatorID)
}

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

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

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

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

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

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

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

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

// 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, 12)
	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)
	}
	if m.token != nil {
		fields = append(fields, soptask.FieldToken)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *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()
	case soptask.FieldToken:
		return m.Token()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *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)
	case soptask.FieldToken:
		return m.OldToken(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
	case soptask.FieldToken:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToken(v)
		return nil
	}
	return fmt.Errorf("unknown 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)
	}
	if m.FieldCleared(soptask.FieldToken) {
		fields = append(fields, soptask.FieldToken)
	}
	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
	case soptask.FieldToken:
		m.ClearToken()
		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
	case soptask.FieldToken:
		m.ResetToken()
		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
	organization_id    *uint64
	addorganization_id *int64
	custom_agent_base  *string
	custom_agent_key   *string
	openai_base        *string
	openai_key         *string
	clearedFields      map[string]struct{}
	agent              *uint64
	clearedagent       bool
	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
}

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

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

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

// SetOrganizationID sets the "organization_id" field.
func (m *TokenMutation) 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 *TokenMutation) 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 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) 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 *TokenMutation) 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 *TokenMutation) 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 *TokenMutation) ResetOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
}

// SetAgentID sets the "agent_id" field.
func (m *TokenMutation) SetAgentID(u uint64) {
	m.agent = &u
}

// AgentID returns the value of the "agent_id" field in the mutation.
func (m *TokenMutation) 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 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) 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 *TokenMutation) ResetAgentID() {
	m.agent = nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ClearAgent clears the "agent" edge to the Agent entity.
func (m *TokenMutation) ClearAgent() {
	m.clearedagent = true
	m.clearedFields[token.FieldAgentID] = struct{}{}
}

// AgentCleared reports if the "agent" edge to the Agent entity was cleared.
func (m *TokenMutation) 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 *TokenMutation) AgentIDs() (ids []uint64) {
	if id := m.agent; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetAgent resets all changes to the "agent" edge.
func (m *TokenMutation) ResetAgent() {
	m.agent = nil
	m.clearedagent = false
}

// 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, 12)
	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)
	}
	if m.organization_id != nil {
		fields = append(fields, token.FieldOrganizationID)
	}
	if m.agent != nil {
		fields = append(fields, token.FieldAgentID)
	}
	if m.custom_agent_base != nil {
		fields = append(fields, token.FieldCustomAgentBase)
	}
	if m.custom_agent_key != nil {
		fields = append(fields, token.FieldCustomAgentKey)
	}
	if m.openai_base != nil {
		fields = append(fields, token.FieldOpenaiBase)
	}
	if m.openai_key != nil {
		fields = append(fields, token.FieldOpenaiKey)
	}
	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()
	case token.FieldOrganizationID:
		return m.OrganizationID()
	case token.FieldAgentID:
		return m.AgentID()
	case token.FieldCustomAgentBase:
		return m.CustomAgentBase()
	case token.FieldCustomAgentKey:
		return m.CustomAgentKey()
	case token.FieldOpenaiBase:
		return m.OpenaiBase()
	case token.FieldOpenaiKey:
		return m.OpenaiKey()
	}
	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)
	case token.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case token.FieldAgentID:
		return m.OldAgentID(ctx)
	case token.FieldCustomAgentBase:
		return m.OldCustomAgentBase(ctx)
	case token.FieldCustomAgentKey:
		return m.OldCustomAgentKey(ctx)
	case token.FieldOpenaiBase:
		return m.OldOpenaiBase(ctx)
	case token.FieldOpenaiKey:
		return m.OldOpenaiKey(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
	case token.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case token.FieldAgentID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAgentID(v)
		return nil
	case token.FieldCustomAgentBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCustomAgentBase(v)
		return nil
	case token.FieldCustomAgentKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCustomAgentKey(v)
		return nil
	case token.FieldOpenaiBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOpenaiBase(v)
		return nil
	case token.FieldOpenaiKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOpenaiKey(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 {
	var fields []string
	if m.addorganization_id != nil {
		fields = append(fields, token.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 *TokenMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case token.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 *TokenMutation) AddField(name string, value ent.Value) error {
	switch name {
	case token.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 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)
	}
	if m.FieldCleared(token.FieldMAC) {
		fields = append(fields, token.FieldMAC)
	}
	if m.FieldCleared(token.FieldCustomAgentBase) {
		fields = append(fields, token.FieldCustomAgentBase)
	}
	if m.FieldCleared(token.FieldCustomAgentKey) {
		fields = append(fields, token.FieldCustomAgentKey)
	}
	if m.FieldCleared(token.FieldOpenaiBase) {
		fields = append(fields, token.FieldOpenaiBase)
	}
	if m.FieldCleared(token.FieldOpenaiKey) {
		fields = append(fields, token.FieldOpenaiKey)
	}
	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
	case token.FieldMAC:
		m.ClearMAC()
		return nil
	case token.FieldCustomAgentBase:
		m.ClearCustomAgentBase()
		return nil
	case token.FieldCustomAgentKey:
		m.ClearCustomAgentKey()
		return nil
	case token.FieldOpenaiBase:
		m.ClearOpenaiBase()
		return nil
	case token.FieldOpenaiKey:
		m.ClearOpenaiKey()
		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
	case token.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case token.FieldAgentID:
		m.ResetAgentID()
		return nil
	case token.FieldCustomAgentBase:
		m.ResetCustomAgentBase()
		return nil
	case token.FieldCustomAgentKey:
		m.ResetCustomAgentKey()
		return nil
	case token.FieldOpenaiBase:
		m.ResetOpenaiBase()
		return nil
	case token.FieldOpenaiKey:
		m.ResetOpenaiKey()
		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, 1)
	if m.agent != nil {
		edges = append(edges, token.EdgeAgent)
	}
	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 {
	switch name {
	case token.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 *TokenMutation) 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 *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, 1)
	if m.clearedagent {
		edges = append(edges, token.EdgeAgent)
	}
	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 {
	switch name {
	case token.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 *TokenMutation) ClearEdge(name string) error {
	switch name {
	case token.EdgeAgent:
		m.ClearAgent()
		return nil
	}
	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 {
	switch name {
	case token.EdgeAgent:
		m.ResetAgent()
		return nil
	}
	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)
}

// UsageDetailMutation represents an operation that mutates the UsageDetail nodes in the graph.
type UsageDetailMutation 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
	bot_id               *string
	receiver_id          *string
	app                  *int
	addapp               *int
	session_id           *uint64
	addsession_id        *int64
	request              *string
	response             *string
	original_data        *custom_types.OriginalData
	total_tokens         *uint64
	addtotal_tokens      *int64
	prompt_tokens        *uint64
	addprompt_tokens     *int64
	completion_tokens    *uint64
	addcompletion_tokens *int64
	organization_id      *uint64
	addorganization_id   *int64
	clearedFields        map[string]struct{}
	done                 bool
	oldValue             func(context.Context) (*UsageDetail, error)
	predicates           []predicate.UsageDetail
}

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

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

// newUsageDetailMutation creates new mutation for the UsageDetail entity.
func newUsageDetailMutation(c config, op Op, opts ...usagedetailOption) *UsageDetailMutation {
	m := &UsageDetailMutation{
		config:        c,
		op:            op,
		typ:           TypeUsageDetail,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[usagedetail.FieldStatus] = struct{}{}
}

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

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

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

// GetType returns the value of the "type" field in the mutation.
func (m *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) ClearType() {
	m._type = nil
	m.add_type = nil
	m.clearedFields[usagedetail.FieldType] = struct{}{}
}

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

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

// SetBotID sets the "bot_id" field.
func (m *UsageDetailMutation) SetBotID(s string) {
	m.bot_id = &s
}

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

// OldBotID returns the old "bot_id" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldBotID(ctx context.Context) (v string, 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
}

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

// SetReceiverID sets the "receiver_id" field.
func (m *UsageDetailMutation) SetReceiverID(s string) {
	m.receiver_id = &s
}

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

// OldReceiverID returns the old "receiver_id" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldReceiverID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldReceiverID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldReceiverID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldReceiverID: %w", err)
	}
	return oldValue.ReceiverID, nil
}

// ResetReceiverID resets all changes to the "receiver_id" field.
func (m *UsageDetailMutation) ResetReceiverID() {
	m.receiver_id = nil
}

// SetApp sets the "app" field.
func (m *UsageDetailMutation) SetApp(i int) {
	m.app = &i
	m.addapp = nil
}

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

// OldApp returns the old "app" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldApp(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldApp is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldApp requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldApp: %w", err)
	}
	return oldValue.App, nil
}

// AddApp adds i to the "app" field.
func (m *UsageDetailMutation) AddApp(i int) {
	if m.addapp != nil {
		*m.addapp += i
	} else {
		m.addapp = &i
	}
}

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

// ClearApp clears the value of the "app" field.
func (m *UsageDetailMutation) ClearApp() {
	m.app = nil
	m.addapp = nil
	m.clearedFields[usagedetail.FieldApp] = struct{}{}
}

// AppCleared returns if the "app" field was cleared in this mutation.
func (m *UsageDetailMutation) AppCleared() bool {
	_, ok := m.clearedFields[usagedetail.FieldApp]
	return ok
}

// ResetApp resets all changes to the "app" field.
func (m *UsageDetailMutation) ResetApp() {
	m.app = nil
	m.addapp = nil
	delete(m.clearedFields, usagedetail.FieldApp)
}

// SetSessionID sets the "session_id" field.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) AddedSessionID() (r int64, exists bool) {
	v := m.addsession_id
	if v == nil {
		return
	}
	return *v, true
}

// ClearSessionID clears the value of the "session_id" field.
func (m *UsageDetailMutation) ClearSessionID() {
	m.session_id = nil
	m.addsession_id = nil
	m.clearedFields[usagedetail.FieldSessionID] = struct{}{}
}

// SessionIDCleared returns if the "session_id" field was cleared in this mutation.
func (m *UsageDetailMutation) SessionIDCleared() bool {
	_, ok := m.clearedFields[usagedetail.FieldSessionID]
	return ok
}

// ResetSessionID resets all changes to the "session_id" field.
func (m *UsageDetailMutation) ResetSessionID() {
	m.session_id = nil
	m.addsession_id = nil
	delete(m.clearedFields, usagedetail.FieldSessionID)
}

// SetRequest sets the "request" field.
func (m *UsageDetailMutation) SetRequest(s string) {
	m.request = &s
}

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

// OldRequest returns the old "request" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldRequest(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldRequest is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldRequest requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldRequest: %w", err)
	}
	return oldValue.Request, nil
}

// ResetRequest resets all changes to the "request" field.
func (m *UsageDetailMutation) ResetRequest() {
	m.request = nil
}

// SetResponse sets the "response" field.
func (m *UsageDetailMutation) SetResponse(s string) {
	m.response = &s
}

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

// OldResponse returns the old "response" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldResponse(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldResponse is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldResponse requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldResponse: %w", err)
	}
	return oldValue.Response, nil
}

// ResetResponse resets all changes to the "response" field.
func (m *UsageDetailMutation) ResetResponse() {
	m.response = nil
}

// SetOriginalData sets the "original_data" field.
func (m *UsageDetailMutation) SetOriginalData(ctd custom_types.OriginalData) {
	m.original_data = &ctd
}

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

// OldOriginalData returns the old "original_data" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldOriginalData(ctx context.Context) (v custom_types.OriginalData, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOriginalData is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOriginalData requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOriginalData: %w", err)
	}
	return oldValue.OriginalData, nil
}

// ResetOriginalData resets all changes to the "original_data" field.
func (m *UsageDetailMutation) ResetOriginalData() {
	m.original_data = nil
}

// SetTotalTokens sets the "total_tokens" field.
func (m *UsageDetailMutation) SetTotalTokens(u uint64) {
	m.total_tokens = &u
	m.addtotal_tokens = nil
}

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

// OldTotalTokens returns the old "total_tokens" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldTotalTokens(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalTokens is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalTokens requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalTokens: %w", err)
	}
	return oldValue.TotalTokens, nil
}

// AddTotalTokens adds u to the "total_tokens" field.
func (m *UsageDetailMutation) AddTotalTokens(u int64) {
	if m.addtotal_tokens != nil {
		*m.addtotal_tokens += u
	} else {
		m.addtotal_tokens = &u
	}
}

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

// ClearTotalTokens clears the value of the "total_tokens" field.
func (m *UsageDetailMutation) ClearTotalTokens() {
	m.total_tokens = nil
	m.addtotal_tokens = nil
	m.clearedFields[usagedetail.FieldTotalTokens] = struct{}{}
}

// TotalTokensCleared returns if the "total_tokens" field was cleared in this mutation.
func (m *UsageDetailMutation) TotalTokensCleared() bool {
	_, ok := m.clearedFields[usagedetail.FieldTotalTokens]
	return ok
}

// ResetTotalTokens resets all changes to the "total_tokens" field.
func (m *UsageDetailMutation) ResetTotalTokens() {
	m.total_tokens = nil
	m.addtotal_tokens = nil
	delete(m.clearedFields, usagedetail.FieldTotalTokens)
}

// SetPromptTokens sets the "prompt_tokens" field.
func (m *UsageDetailMutation) SetPromptTokens(u uint64) {
	m.prompt_tokens = &u
	m.addprompt_tokens = nil
}

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

// OldPromptTokens returns the old "prompt_tokens" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldPromptTokens(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPromptTokens is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPromptTokens requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPromptTokens: %w", err)
	}
	return oldValue.PromptTokens, nil
}

// AddPromptTokens adds u to the "prompt_tokens" field.
func (m *UsageDetailMutation) AddPromptTokens(u int64) {
	if m.addprompt_tokens != nil {
		*m.addprompt_tokens += u
	} else {
		m.addprompt_tokens = &u
	}
}

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

// ClearPromptTokens clears the value of the "prompt_tokens" field.
func (m *UsageDetailMutation) ClearPromptTokens() {
	m.prompt_tokens = nil
	m.addprompt_tokens = nil
	m.clearedFields[usagedetail.FieldPromptTokens] = struct{}{}
}

// PromptTokensCleared returns if the "prompt_tokens" field was cleared in this mutation.
func (m *UsageDetailMutation) PromptTokensCleared() bool {
	_, ok := m.clearedFields[usagedetail.FieldPromptTokens]
	return ok
}

// ResetPromptTokens resets all changes to the "prompt_tokens" field.
func (m *UsageDetailMutation) ResetPromptTokens() {
	m.prompt_tokens = nil
	m.addprompt_tokens = nil
	delete(m.clearedFields, usagedetail.FieldPromptTokens)
}

// SetCompletionTokens sets the "completion_tokens" field.
func (m *UsageDetailMutation) SetCompletionTokens(u uint64) {
	m.completion_tokens = &u
	m.addcompletion_tokens = nil
}

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

// OldCompletionTokens returns the old "completion_tokens" field's value of the UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) OldCompletionTokens(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCompletionTokens is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCompletionTokens requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCompletionTokens: %w", err)
	}
	return oldValue.CompletionTokens, nil
}

// AddCompletionTokens adds u to the "completion_tokens" field.
func (m *UsageDetailMutation) AddCompletionTokens(u int64) {
	if m.addcompletion_tokens != nil {
		*m.addcompletion_tokens += u
	} else {
		m.addcompletion_tokens = &u
	}
}

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

// ClearCompletionTokens clears the value of the "completion_tokens" field.
func (m *UsageDetailMutation) ClearCompletionTokens() {
	m.completion_tokens = nil
	m.addcompletion_tokens = nil
	m.clearedFields[usagedetail.FieldCompletionTokens] = struct{}{}
}

// CompletionTokensCleared returns if the "completion_tokens" field was cleared in this mutation.
func (m *UsageDetailMutation) CompletionTokensCleared() bool {
	_, ok := m.clearedFields[usagedetail.FieldCompletionTokens]
	return ok
}

// ResetCompletionTokens resets all changes to the "completion_tokens" field.
func (m *UsageDetailMutation) ResetCompletionTokens() {
	m.completion_tokens = nil
	m.addcompletion_tokens = nil
	delete(m.clearedFields, usagedetail.FieldCompletionTokens)
}

// SetOrganizationID sets the "organization_id" field.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 UsageDetail entity.
// If the UsageDetail object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) 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 *UsageDetailMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[usagedetail.FieldOrganizationID] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (UsageDetail).
func (m *UsageDetailMutation) 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 *UsageDetailMutation) Fields() []string {
	fields := make([]string, 0, 15)
	if m.created_at != nil {
		fields = append(fields, usagedetail.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, usagedetail.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, usagedetail.FieldStatus)
	}
	if m._type != nil {
		fields = append(fields, usagedetail.FieldType)
	}
	if m.bot_id != nil {
		fields = append(fields, usagedetail.FieldBotID)
	}
	if m.receiver_id != nil {
		fields = append(fields, usagedetail.FieldReceiverID)
	}
	if m.app != nil {
		fields = append(fields, usagedetail.FieldApp)
	}
	if m.session_id != nil {
		fields = append(fields, usagedetail.FieldSessionID)
	}
	if m.request != nil {
		fields = append(fields, usagedetail.FieldRequest)
	}
	if m.response != nil {
		fields = append(fields, usagedetail.FieldResponse)
	}
	if m.original_data != nil {
		fields = append(fields, usagedetail.FieldOriginalData)
	}
	if m.total_tokens != nil {
		fields = append(fields, usagedetail.FieldTotalTokens)
	}
	if m.prompt_tokens != nil {
		fields = append(fields, usagedetail.FieldPromptTokens)
	}
	if m.completion_tokens != nil {
		fields = append(fields, usagedetail.FieldCompletionTokens)
	}
	if m.organization_id != nil {
		fields = append(fields, usagedetail.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 *UsageDetailMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case usagedetail.FieldCreatedAt:
		return m.CreatedAt()
	case usagedetail.FieldUpdatedAt:
		return m.UpdatedAt()
	case usagedetail.FieldStatus:
		return m.Status()
	case usagedetail.FieldType:
		return m.GetType()
	case usagedetail.FieldBotID:
		return m.BotID()
	case usagedetail.FieldReceiverID:
		return m.ReceiverID()
	case usagedetail.FieldApp:
		return m.App()
	case usagedetail.FieldSessionID:
		return m.SessionID()
	case usagedetail.FieldRequest:
		return m.Request()
	case usagedetail.FieldResponse:
		return m.Response()
	case usagedetail.FieldOriginalData:
		return m.OriginalData()
	case usagedetail.FieldTotalTokens:
		return m.TotalTokens()
	case usagedetail.FieldPromptTokens:
		return m.PromptTokens()
	case usagedetail.FieldCompletionTokens:
		return m.CompletionTokens()
	case usagedetail.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 *UsageDetailMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case usagedetail.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case usagedetail.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case usagedetail.FieldStatus:
		return m.OldStatus(ctx)
	case usagedetail.FieldType:
		return m.OldType(ctx)
	case usagedetail.FieldBotID:
		return m.OldBotID(ctx)
	case usagedetail.FieldReceiverID:
		return m.OldReceiverID(ctx)
	case usagedetail.FieldApp:
		return m.OldApp(ctx)
	case usagedetail.FieldSessionID:
		return m.OldSessionID(ctx)
	case usagedetail.FieldRequest:
		return m.OldRequest(ctx)
	case usagedetail.FieldResponse:
		return m.OldResponse(ctx)
	case usagedetail.FieldOriginalData:
		return m.OldOriginalData(ctx)
	case usagedetail.FieldTotalTokens:
		return m.OldTotalTokens(ctx)
	case usagedetail.FieldPromptTokens:
		return m.OldPromptTokens(ctx)
	case usagedetail.FieldCompletionTokens:
		return m.OldCompletionTokens(ctx)
	case usagedetail.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown UsageDetail 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 *UsageDetailMutation) SetField(name string, value ent.Value) error {
	switch name {
	case usagedetail.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 usagedetail.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 usagedetail.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case usagedetail.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case usagedetail.FieldBotID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case usagedetail.FieldReceiverID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReceiverID(v)
		return nil
	case usagedetail.FieldApp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetApp(v)
		return nil
	case usagedetail.FieldSessionID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSessionID(v)
		return nil
	case usagedetail.FieldRequest:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRequest(v)
		return nil
	case usagedetail.FieldResponse:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetResponse(v)
		return nil
	case usagedetail.FieldOriginalData:
		v, ok := value.(custom_types.OriginalData)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOriginalData(v)
		return nil
	case usagedetail.FieldTotalTokens:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalTokens(v)
		return nil
	case usagedetail.FieldPromptTokens:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPromptTokens(v)
		return nil
	case usagedetail.FieldCompletionTokens:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCompletionTokens(v)
		return nil
	case usagedetail.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 UsageDetail field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsageDetailMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, usagedetail.FieldStatus)
	}
	if m.add_type != nil {
		fields = append(fields, usagedetail.FieldType)
	}
	if m.addapp != nil {
		fields = append(fields, usagedetail.FieldApp)
	}
	if m.addsession_id != nil {
		fields = append(fields, usagedetail.FieldSessionID)
	}
	if m.addtotal_tokens != nil {
		fields = append(fields, usagedetail.FieldTotalTokens)
	}
	if m.addprompt_tokens != nil {
		fields = append(fields, usagedetail.FieldPromptTokens)
	}
	if m.addcompletion_tokens != nil {
		fields = append(fields, usagedetail.FieldCompletionTokens)
	}
	if m.addorganization_id != nil {
		fields = append(fields, usagedetail.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 *UsageDetailMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case usagedetail.FieldStatus:
		return m.AddedStatus()
	case usagedetail.FieldType:
		return m.AddedType()
	case usagedetail.FieldApp:
		return m.AddedApp()
	case usagedetail.FieldSessionID:
		return m.AddedSessionID()
	case usagedetail.FieldTotalTokens:
		return m.AddedTotalTokens()
	case usagedetail.FieldPromptTokens:
		return m.AddedPromptTokens()
	case usagedetail.FieldCompletionTokens:
		return m.AddedCompletionTokens()
	case usagedetail.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 *UsageDetailMutation) AddField(name string, value ent.Value) error {
	switch name {
	case usagedetail.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case usagedetail.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case usagedetail.FieldApp:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddApp(v)
		return nil
	case usagedetail.FieldSessionID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSessionID(v)
		return nil
	case usagedetail.FieldTotalTokens:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalTokens(v)
		return nil
	case usagedetail.FieldPromptTokens:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPromptTokens(v)
		return nil
	case usagedetail.FieldCompletionTokens:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCompletionTokens(v)
		return nil
	case usagedetail.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 UsageDetail numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *UsageDetailMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(usagedetail.FieldStatus) {
		fields = append(fields, usagedetail.FieldStatus)
	}
	if m.FieldCleared(usagedetail.FieldType) {
		fields = append(fields, usagedetail.FieldType)
	}
	if m.FieldCleared(usagedetail.FieldApp) {
		fields = append(fields, usagedetail.FieldApp)
	}
	if m.FieldCleared(usagedetail.FieldSessionID) {
		fields = append(fields, usagedetail.FieldSessionID)
	}
	if m.FieldCleared(usagedetail.FieldTotalTokens) {
		fields = append(fields, usagedetail.FieldTotalTokens)
	}
	if m.FieldCleared(usagedetail.FieldPromptTokens) {
		fields = append(fields, usagedetail.FieldPromptTokens)
	}
	if m.FieldCleared(usagedetail.FieldCompletionTokens) {
		fields = append(fields, usagedetail.FieldCompletionTokens)
	}
	if m.FieldCleared(usagedetail.FieldOrganizationID) {
		fields = append(fields, usagedetail.FieldOrganizationID)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsageDetailMutation) 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 *UsageDetailMutation) ClearField(name string) error {
	switch name {
	case usagedetail.FieldStatus:
		m.ClearStatus()
		return nil
	case usagedetail.FieldType:
		m.ClearType()
		return nil
	case usagedetail.FieldApp:
		m.ClearApp()
		return nil
	case usagedetail.FieldSessionID:
		m.ClearSessionID()
		return nil
	case usagedetail.FieldTotalTokens:
		m.ClearTotalTokens()
		return nil
	case usagedetail.FieldPromptTokens:
		m.ClearPromptTokens()
		return nil
	case usagedetail.FieldCompletionTokens:
		m.ClearCompletionTokens()
		return nil
	case usagedetail.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageDetail 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 *UsageDetailMutation) ResetField(name string) error {
	switch name {
	case usagedetail.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case usagedetail.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case usagedetail.FieldStatus:
		m.ResetStatus()
		return nil
	case usagedetail.FieldType:
		m.ResetType()
		return nil
	case usagedetail.FieldBotID:
		m.ResetBotID()
		return nil
	case usagedetail.FieldReceiverID:
		m.ResetReceiverID()
		return nil
	case usagedetail.FieldApp:
		m.ResetApp()
		return nil
	case usagedetail.FieldSessionID:
		m.ResetSessionID()
		return nil
	case usagedetail.FieldRequest:
		m.ResetRequest()
		return nil
	case usagedetail.FieldResponse:
		m.ResetResponse()
		return nil
	case usagedetail.FieldOriginalData:
		m.ResetOriginalData()
		return nil
	case usagedetail.FieldTotalTokens:
		m.ResetTotalTokens()
		return nil
	case usagedetail.FieldPromptTokens:
		m.ResetPromptTokens()
		return nil
	case usagedetail.FieldCompletionTokens:
		m.ResetCompletionTokens()
		return nil
	case usagedetail.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageDetail field %s", name)
}

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

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

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

// UsageStatisticDayMutation represents an operation that mutates the UsageStatisticDay nodes in the graph.
type UsageStatisticDayMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	status             *uint8
	addstatus          *int8
	deleted_at         *time.Time
	addtime            *uint64
	addaddtime         *int64
	_type              *int
	add_type           *int
	bot_id             *string
	organization_id    *uint64
	addorganization_id *int64
	ai_response        *uint64
	addai_response     *int64
	sop_run            *uint64
	addsop_run         *int64
	total_friend       *uint64
	addtotal_friend    *int64
	total_group        *uint64
	addtotal_group     *int64
	account_balance    *uint64
	addaccount_balance *int64
	consume_token      *uint64
	addconsume_token   *int64
	active_user        *uint64
	addactive_user     *int64
	new_user           *int64
	addnew_user        *int64
	label_dist         *[]custom_types.LabelDist
	appendlabel_dist   []custom_types.LabelDist
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*UsageStatisticDay, error)
	predicates         []predicate.UsageStatisticDay
}

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

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

// newUsageStatisticDayMutation creates new mutation for the UsageStatisticDay entity.
func newUsageStatisticDayMutation(c config, op Op, opts ...usagestatisticdayOption) *UsageStatisticDayMutation {
	m := &UsageStatisticDayMutation{
		config:        c,
		op:            op,
		typ:           TypeUsageStatisticDay,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[usagestatisticday.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[usagestatisticday.FieldDeletedAt] = struct{}{}
}

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

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

// SetAddtime sets the "addtime" field.
func (m *UsageStatisticDayMutation) SetAddtime(u uint64) {
	m.addtime = &u
	m.addaddtime = nil
}

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

// OldAddtime returns the old "addtime" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldAddtime(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAddtime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAddtime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAddtime: %w", err)
	}
	return oldValue.Addtime, nil
}

// AddAddtime adds u to the "addtime" field.
func (m *UsageStatisticDayMutation) AddAddtime(u int64) {
	if m.addaddtime != nil {
		*m.addaddtime += u
	} else {
		m.addaddtime = &u
	}
}

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

// ResetAddtime resets all changes to the "addtime" field.
func (m *UsageStatisticDayMutation) ResetAddtime() {
	m.addtime = nil
	m.addaddtime = nil
}

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

// GetType returns the value of the "type" field in the mutation.
func (m *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ResetType() {
	m._type = nil
	m.add_type = nil
}

// SetBotID sets the "bot_id" field.
func (m *UsageStatisticDayMutation) SetBotID(s string) {
	m.bot_id = &s
}

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

// OldBotID returns the old "bot_id" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldBotID(ctx context.Context) (v string, 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
}

// ClearBotID clears the value of the "bot_id" field.
func (m *UsageStatisticDayMutation) ClearBotID() {
	m.bot_id = nil
	m.clearedFields[usagestatisticday.FieldBotID] = struct{}{}
}

// BotIDCleared returns if the "bot_id" field was cleared in this mutation.
func (m *UsageStatisticDayMutation) BotIDCleared() bool {
	_, ok := m.clearedFields[usagestatisticday.FieldBotID]
	return ok
}

// ResetBotID resets all changes to the "bot_id" field.
func (m *UsageStatisticDayMutation) ResetBotID() {
	m.bot_id = nil
	delete(m.clearedFields, usagestatisticday.FieldBotID)
}

// SetOrganizationID sets the "organization_id" field.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[usagestatisticday.FieldOrganizationID] = struct{}{}
}

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

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

// SetAiResponse sets the "ai_response" field.
func (m *UsageStatisticDayMutation) SetAiResponse(u uint64) {
	m.ai_response = &u
	m.addai_response = nil
}

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

// OldAiResponse returns the old "ai_response" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldAiResponse(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAiResponse is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAiResponse requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAiResponse: %w", err)
	}
	return oldValue.AiResponse, nil
}

// AddAiResponse adds u to the "ai_response" field.
func (m *UsageStatisticDayMutation) AddAiResponse(u int64) {
	if m.addai_response != nil {
		*m.addai_response += u
	} else {
		m.addai_response = &u
	}
}

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

// ResetAiResponse resets all changes to the "ai_response" field.
func (m *UsageStatisticDayMutation) ResetAiResponse() {
	m.ai_response = nil
	m.addai_response = nil
}

// SetSopRun sets the "sop_run" field.
func (m *UsageStatisticDayMutation) SetSopRun(u uint64) {
	m.sop_run = &u
	m.addsop_run = nil
}

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

// OldSopRun returns the old "sop_run" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldSopRun(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSopRun is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSopRun requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSopRun: %w", err)
	}
	return oldValue.SopRun, nil
}

// AddSopRun adds u to the "sop_run" field.
func (m *UsageStatisticDayMutation) AddSopRun(u int64) {
	if m.addsop_run != nil {
		*m.addsop_run += u
	} else {
		m.addsop_run = &u
	}
}

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

// ResetSopRun resets all changes to the "sop_run" field.
func (m *UsageStatisticDayMutation) ResetSopRun() {
	m.sop_run = nil
	m.addsop_run = nil
}

// SetTotalFriend sets the "total_friend" field.
func (m *UsageStatisticDayMutation) SetTotalFriend(u uint64) {
	m.total_friend = &u
	m.addtotal_friend = nil
}

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

// OldTotalFriend returns the old "total_friend" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldTotalFriend(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalFriend is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalFriend requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalFriend: %w", err)
	}
	return oldValue.TotalFriend, nil
}

// AddTotalFriend adds u to the "total_friend" field.
func (m *UsageStatisticDayMutation) AddTotalFriend(u int64) {
	if m.addtotal_friend != nil {
		*m.addtotal_friend += u
	} else {
		m.addtotal_friend = &u
	}
}

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

// ResetTotalFriend resets all changes to the "total_friend" field.
func (m *UsageStatisticDayMutation) ResetTotalFriend() {
	m.total_friend = nil
	m.addtotal_friend = nil
}

// SetTotalGroup sets the "total_group" field.
func (m *UsageStatisticDayMutation) SetTotalGroup(u uint64) {
	m.total_group = &u
	m.addtotal_group = nil
}

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

// OldTotalGroup returns the old "total_group" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldTotalGroup(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalGroup is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalGroup requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalGroup: %w", err)
	}
	return oldValue.TotalGroup, nil
}

// AddTotalGroup adds u to the "total_group" field.
func (m *UsageStatisticDayMutation) AddTotalGroup(u int64) {
	if m.addtotal_group != nil {
		*m.addtotal_group += u
	} else {
		m.addtotal_group = &u
	}
}

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

// ResetTotalGroup resets all changes to the "total_group" field.
func (m *UsageStatisticDayMutation) ResetTotalGroup() {
	m.total_group = nil
	m.addtotal_group = nil
}

// SetAccountBalance sets the "account_balance" field.
func (m *UsageStatisticDayMutation) SetAccountBalance(u uint64) {
	m.account_balance = &u
	m.addaccount_balance = nil
}

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

// OldAccountBalance returns the old "account_balance" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldAccountBalance(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAccountBalance is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAccountBalance requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAccountBalance: %w", err)
	}
	return oldValue.AccountBalance, nil
}

// AddAccountBalance adds u to the "account_balance" field.
func (m *UsageStatisticDayMutation) AddAccountBalance(u int64) {
	if m.addaccount_balance != nil {
		*m.addaccount_balance += u
	} else {
		m.addaccount_balance = &u
	}
}

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

// ResetAccountBalance resets all changes to the "account_balance" field.
func (m *UsageStatisticDayMutation) ResetAccountBalance() {
	m.account_balance = nil
	m.addaccount_balance = nil
}

// SetConsumeToken sets the "consume_token" field.
func (m *UsageStatisticDayMutation) SetConsumeToken(u uint64) {
	m.consume_token = &u
	m.addconsume_token = nil
}

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

// OldConsumeToken returns the old "consume_token" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldConsumeToken(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldConsumeToken is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldConsumeToken requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldConsumeToken: %w", err)
	}
	return oldValue.ConsumeToken, nil
}

// AddConsumeToken adds u to the "consume_token" field.
func (m *UsageStatisticDayMutation) AddConsumeToken(u int64) {
	if m.addconsume_token != nil {
		*m.addconsume_token += u
	} else {
		m.addconsume_token = &u
	}
}

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

// ResetConsumeToken resets all changes to the "consume_token" field.
func (m *UsageStatisticDayMutation) ResetConsumeToken() {
	m.consume_token = nil
	m.addconsume_token = nil
}

// SetActiveUser sets the "active_user" field.
func (m *UsageStatisticDayMutation) SetActiveUser(u uint64) {
	m.active_user = &u
	m.addactive_user = nil
}

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

// OldActiveUser returns the old "active_user" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldActiveUser(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldActiveUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldActiveUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldActiveUser: %w", err)
	}
	return oldValue.ActiveUser, nil
}

// AddActiveUser adds u to the "active_user" field.
func (m *UsageStatisticDayMutation) AddActiveUser(u int64) {
	if m.addactive_user != nil {
		*m.addactive_user += u
	} else {
		m.addactive_user = &u
	}
}

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

// ResetActiveUser resets all changes to the "active_user" field.
func (m *UsageStatisticDayMutation) ResetActiveUser() {
	m.active_user = nil
	m.addactive_user = nil
}

// SetNewUser sets the "new_user" field.
func (m *UsageStatisticDayMutation) SetNewUser(i int64) {
	m.new_user = &i
	m.addnew_user = nil
}

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

// OldNewUser returns the old "new_user" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldNewUser(ctx context.Context) (v int64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNewUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNewUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNewUser: %w", err)
	}
	return oldValue.NewUser, nil
}

// AddNewUser adds i to the "new_user" field.
func (m *UsageStatisticDayMutation) AddNewUser(i int64) {
	if m.addnew_user != nil {
		*m.addnew_user += i
	} else {
		m.addnew_user = &i
	}
}

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

// ResetNewUser resets all changes to the "new_user" field.
func (m *UsageStatisticDayMutation) ResetNewUser() {
	m.new_user = nil
	m.addnew_user = nil
}

// SetLabelDist sets the "label_dist" field.
func (m *UsageStatisticDayMutation) SetLabelDist(ctd []custom_types.LabelDist) {
	m.label_dist = &ctd
	m.appendlabel_dist = nil
}

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

// OldLabelDist returns the old "label_dist" field's value of the UsageStatisticDay entity.
// If the UsageStatisticDay object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticDayMutation) OldLabelDist(ctx context.Context) (v []custom_types.LabelDist, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldLabelDist is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldLabelDist requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldLabelDist: %w", err)
	}
	return oldValue.LabelDist, nil
}

// AppendLabelDist adds ctd to the "label_dist" field.
func (m *UsageStatisticDayMutation) AppendLabelDist(ctd []custom_types.LabelDist) {
	m.appendlabel_dist = append(m.appendlabel_dist, ctd...)
}

// AppendedLabelDist returns the list of values that were appended to the "label_dist" field in this mutation.
func (m *UsageStatisticDayMutation) AppendedLabelDist() ([]custom_types.LabelDist, bool) {
	if len(m.appendlabel_dist) == 0 {
		return nil, false
	}
	return m.appendlabel_dist, true
}

// ResetLabelDist resets all changes to the "label_dist" field.
func (m *UsageStatisticDayMutation) ResetLabelDist() {
	m.label_dist = nil
	m.appendlabel_dist = nil
}

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

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

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

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

// Type returns the node type of this mutation (UsageStatisticDay).
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) Fields() []string {
	fields := make([]string, 0, 17)
	if m.created_at != nil {
		fields = append(fields, usagestatisticday.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, usagestatisticday.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, usagestatisticday.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, usagestatisticday.FieldDeletedAt)
	}
	if m.addtime != nil {
		fields = append(fields, usagestatisticday.FieldAddtime)
	}
	if m._type != nil {
		fields = append(fields, usagestatisticday.FieldType)
	}
	if m.bot_id != nil {
		fields = append(fields, usagestatisticday.FieldBotID)
	}
	if m.organization_id != nil {
		fields = append(fields, usagestatisticday.FieldOrganizationID)
	}
	if m.ai_response != nil {
		fields = append(fields, usagestatisticday.FieldAiResponse)
	}
	if m.sop_run != nil {
		fields = append(fields, usagestatisticday.FieldSopRun)
	}
	if m.total_friend != nil {
		fields = append(fields, usagestatisticday.FieldTotalFriend)
	}
	if m.total_group != nil {
		fields = append(fields, usagestatisticday.FieldTotalGroup)
	}
	if m.account_balance != nil {
		fields = append(fields, usagestatisticday.FieldAccountBalance)
	}
	if m.consume_token != nil {
		fields = append(fields, usagestatisticday.FieldConsumeToken)
	}
	if m.active_user != nil {
		fields = append(fields, usagestatisticday.FieldActiveUser)
	}
	if m.new_user != nil {
		fields = append(fields, usagestatisticday.FieldNewUser)
	}
	if m.label_dist != nil {
		fields = append(fields, usagestatisticday.FieldLabelDist)
	}
	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 *UsageStatisticDayMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case usagestatisticday.FieldCreatedAt:
		return m.CreatedAt()
	case usagestatisticday.FieldUpdatedAt:
		return m.UpdatedAt()
	case usagestatisticday.FieldStatus:
		return m.Status()
	case usagestatisticday.FieldDeletedAt:
		return m.DeletedAt()
	case usagestatisticday.FieldAddtime:
		return m.Addtime()
	case usagestatisticday.FieldType:
		return m.GetType()
	case usagestatisticday.FieldBotID:
		return m.BotID()
	case usagestatisticday.FieldOrganizationID:
		return m.OrganizationID()
	case usagestatisticday.FieldAiResponse:
		return m.AiResponse()
	case usagestatisticday.FieldSopRun:
		return m.SopRun()
	case usagestatisticday.FieldTotalFriend:
		return m.TotalFriend()
	case usagestatisticday.FieldTotalGroup:
		return m.TotalGroup()
	case usagestatisticday.FieldAccountBalance:
		return m.AccountBalance()
	case usagestatisticday.FieldConsumeToken:
		return m.ConsumeToken()
	case usagestatisticday.FieldActiveUser:
		return m.ActiveUser()
	case usagestatisticday.FieldNewUser:
		return m.NewUser()
	case usagestatisticday.FieldLabelDist:
		return m.LabelDist()
	}
	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 *UsageStatisticDayMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case usagestatisticday.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case usagestatisticday.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case usagestatisticday.FieldStatus:
		return m.OldStatus(ctx)
	case usagestatisticday.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case usagestatisticday.FieldAddtime:
		return m.OldAddtime(ctx)
	case usagestatisticday.FieldType:
		return m.OldType(ctx)
	case usagestatisticday.FieldBotID:
		return m.OldBotID(ctx)
	case usagestatisticday.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case usagestatisticday.FieldAiResponse:
		return m.OldAiResponse(ctx)
	case usagestatisticday.FieldSopRun:
		return m.OldSopRun(ctx)
	case usagestatisticday.FieldTotalFriend:
		return m.OldTotalFriend(ctx)
	case usagestatisticday.FieldTotalGroup:
		return m.OldTotalGroup(ctx)
	case usagestatisticday.FieldAccountBalance:
		return m.OldAccountBalance(ctx)
	case usagestatisticday.FieldConsumeToken:
		return m.OldConsumeToken(ctx)
	case usagestatisticday.FieldActiveUser:
		return m.OldActiveUser(ctx)
	case usagestatisticday.FieldNewUser:
		return m.OldNewUser(ctx)
	case usagestatisticday.FieldLabelDist:
		return m.OldLabelDist(ctx)
	}
	return nil, fmt.Errorf("unknown UsageStatisticDay 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 *UsageStatisticDayMutation) SetField(name string, value ent.Value) error {
	switch name {
	case usagestatisticday.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 usagestatisticday.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 usagestatisticday.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case usagestatisticday.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 usagestatisticday.FieldAddtime:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAddtime(v)
		return nil
	case usagestatisticday.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case usagestatisticday.FieldBotID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case usagestatisticday.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case usagestatisticday.FieldAiResponse:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAiResponse(v)
		return nil
	case usagestatisticday.FieldSopRun:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSopRun(v)
		return nil
	case usagestatisticday.FieldTotalFriend:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalFriend(v)
		return nil
	case usagestatisticday.FieldTotalGroup:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalGroup(v)
		return nil
	case usagestatisticday.FieldAccountBalance:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccountBalance(v)
		return nil
	case usagestatisticday.FieldConsumeToken:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConsumeToken(v)
		return nil
	case usagestatisticday.FieldActiveUser:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActiveUser(v)
		return nil
	case usagestatisticday.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNewUser(v)
		return nil
	case usagestatisticday.FieldLabelDist:
		v, ok := value.([]custom_types.LabelDist)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLabelDist(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticDay field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsageStatisticDayMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, usagestatisticday.FieldStatus)
	}
	if m.addaddtime != nil {
		fields = append(fields, usagestatisticday.FieldAddtime)
	}
	if m.add_type != nil {
		fields = append(fields, usagestatisticday.FieldType)
	}
	if m.addorganization_id != nil {
		fields = append(fields, usagestatisticday.FieldOrganizationID)
	}
	if m.addai_response != nil {
		fields = append(fields, usagestatisticday.FieldAiResponse)
	}
	if m.addsop_run != nil {
		fields = append(fields, usagestatisticday.FieldSopRun)
	}
	if m.addtotal_friend != nil {
		fields = append(fields, usagestatisticday.FieldTotalFriend)
	}
	if m.addtotal_group != nil {
		fields = append(fields, usagestatisticday.FieldTotalGroup)
	}
	if m.addaccount_balance != nil {
		fields = append(fields, usagestatisticday.FieldAccountBalance)
	}
	if m.addconsume_token != nil {
		fields = append(fields, usagestatisticday.FieldConsumeToken)
	}
	if m.addactive_user != nil {
		fields = append(fields, usagestatisticday.FieldActiveUser)
	}
	if m.addnew_user != nil {
		fields = append(fields, usagestatisticday.FieldNewUser)
	}
	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 *UsageStatisticDayMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case usagestatisticday.FieldStatus:
		return m.AddedStatus()
	case usagestatisticday.FieldAddtime:
		return m.AddedAddtime()
	case usagestatisticday.FieldType:
		return m.AddedType()
	case usagestatisticday.FieldOrganizationID:
		return m.AddedOrganizationID()
	case usagestatisticday.FieldAiResponse:
		return m.AddedAiResponse()
	case usagestatisticday.FieldSopRun:
		return m.AddedSopRun()
	case usagestatisticday.FieldTotalFriend:
		return m.AddedTotalFriend()
	case usagestatisticday.FieldTotalGroup:
		return m.AddedTotalGroup()
	case usagestatisticday.FieldAccountBalance:
		return m.AddedAccountBalance()
	case usagestatisticday.FieldConsumeToken:
		return m.AddedConsumeToken()
	case usagestatisticday.FieldActiveUser:
		return m.AddedActiveUser()
	case usagestatisticday.FieldNewUser:
		return m.AddedNewUser()
	}
	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 *UsageStatisticDayMutation) AddField(name string, value ent.Value) error {
	switch name {
	case usagestatisticday.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case usagestatisticday.FieldAddtime:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAddtime(v)
		return nil
	case usagestatisticday.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case usagestatisticday.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case usagestatisticday.FieldAiResponse:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAiResponse(v)
		return nil
	case usagestatisticday.FieldSopRun:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSopRun(v)
		return nil
	case usagestatisticday.FieldTotalFriend:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalFriend(v)
		return nil
	case usagestatisticday.FieldTotalGroup:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalGroup(v)
		return nil
	case usagestatisticday.FieldAccountBalance:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAccountBalance(v)
		return nil
	case usagestatisticday.FieldConsumeToken:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConsumeToken(v)
		return nil
	case usagestatisticday.FieldActiveUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddActiveUser(v)
		return nil
	case usagestatisticday.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNewUser(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticDay numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsageStatisticDayMutation) 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 *UsageStatisticDayMutation) ClearField(name string) error {
	switch name {
	case usagestatisticday.FieldStatus:
		m.ClearStatus()
		return nil
	case usagestatisticday.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case usagestatisticday.FieldBotID:
		m.ClearBotID()
		return nil
	case usagestatisticday.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticDay 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 *UsageStatisticDayMutation) ResetField(name string) error {
	switch name {
	case usagestatisticday.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case usagestatisticday.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case usagestatisticday.FieldStatus:
		m.ResetStatus()
		return nil
	case usagestatisticday.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case usagestatisticday.FieldAddtime:
		m.ResetAddtime()
		return nil
	case usagestatisticday.FieldType:
		m.ResetType()
		return nil
	case usagestatisticday.FieldBotID:
		m.ResetBotID()
		return nil
	case usagestatisticday.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case usagestatisticday.FieldAiResponse:
		m.ResetAiResponse()
		return nil
	case usagestatisticday.FieldSopRun:
		m.ResetSopRun()
		return nil
	case usagestatisticday.FieldTotalFriend:
		m.ResetTotalFriend()
		return nil
	case usagestatisticday.FieldTotalGroup:
		m.ResetTotalGroup()
		return nil
	case usagestatisticday.FieldAccountBalance:
		m.ResetAccountBalance()
		return nil
	case usagestatisticday.FieldConsumeToken:
		m.ResetConsumeToken()
		return nil
	case usagestatisticday.FieldActiveUser:
		m.ResetActiveUser()
		return nil
	case usagestatisticday.FieldNewUser:
		m.ResetNewUser()
		return nil
	case usagestatisticday.FieldLabelDist:
		m.ResetLabelDist()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticDay field %s", name)
}

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

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

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

// UsageStatisticHourMutation represents an operation that mutates the UsageStatisticHour nodes in the graph.
type UsageStatisticHourMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	status             *uint8
	addstatus          *int8
	deleted_at         *time.Time
	addtime            *uint64
	addaddtime         *int64
	_type              *int
	add_type           *int
	bot_id             *string
	organization_id    *uint64
	addorganization_id *int64
	ai_response        *uint64
	addai_response     *int64
	sop_run            *uint64
	addsop_run         *int64
	total_friend       *uint64
	addtotal_friend    *int64
	total_group        *uint64
	addtotal_group     *int64
	account_balance    *uint64
	addaccount_balance *int64
	consume_token      *uint64
	addconsume_token   *int64
	active_user        *uint64
	addactive_user     *int64
	new_user           *int64
	addnew_user        *int64
	label_dist         *[]custom_types.LabelDist
	appendlabel_dist   []custom_types.LabelDist
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*UsageStatisticHour, error)
	predicates         []predicate.UsageStatisticHour
}

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

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

// newUsageStatisticHourMutation creates new mutation for the UsageStatisticHour entity.
func newUsageStatisticHourMutation(c config, op Op, opts ...usagestatistichourOption) *UsageStatisticHourMutation {
	m := &UsageStatisticHourMutation{
		config:        c,
		op:            op,
		typ:           TypeUsageStatisticHour,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[usagestatistichour.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[usagestatistichour.FieldDeletedAt] = struct{}{}
}

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

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

// SetAddtime sets the "addtime" field.
func (m *UsageStatisticHourMutation) SetAddtime(u uint64) {
	m.addtime = &u
	m.addaddtime = nil
}

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

// OldAddtime returns the old "addtime" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldAddtime(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAddtime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAddtime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAddtime: %w", err)
	}
	return oldValue.Addtime, nil
}

// AddAddtime adds u to the "addtime" field.
func (m *UsageStatisticHourMutation) AddAddtime(u int64) {
	if m.addaddtime != nil {
		*m.addaddtime += u
	} else {
		m.addaddtime = &u
	}
}

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

// ResetAddtime resets all changes to the "addtime" field.
func (m *UsageStatisticHourMutation) ResetAddtime() {
	m.addtime = nil
	m.addaddtime = nil
}

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

// GetType returns the value of the "type" field in the mutation.
func (m *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ResetType() {
	m._type = nil
	m.add_type = nil
}

// SetBotID sets the "bot_id" field.
func (m *UsageStatisticHourMutation) SetBotID(s string) {
	m.bot_id = &s
}

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

// OldBotID returns the old "bot_id" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldBotID(ctx context.Context) (v string, 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
}

// ClearBotID clears the value of the "bot_id" field.
func (m *UsageStatisticHourMutation) ClearBotID() {
	m.bot_id = nil
	m.clearedFields[usagestatistichour.FieldBotID] = struct{}{}
}

// BotIDCleared returns if the "bot_id" field was cleared in this mutation.
func (m *UsageStatisticHourMutation) BotIDCleared() bool {
	_, ok := m.clearedFields[usagestatistichour.FieldBotID]
	return ok
}

// ResetBotID resets all changes to the "bot_id" field.
func (m *UsageStatisticHourMutation) ResetBotID() {
	m.bot_id = nil
	delete(m.clearedFields, usagestatistichour.FieldBotID)
}

// SetOrganizationID sets the "organization_id" field.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[usagestatistichour.FieldOrganizationID] = struct{}{}
}

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

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

// SetAiResponse sets the "ai_response" field.
func (m *UsageStatisticHourMutation) SetAiResponse(u uint64) {
	m.ai_response = &u
	m.addai_response = nil
}

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

// OldAiResponse returns the old "ai_response" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldAiResponse(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAiResponse is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAiResponse requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAiResponse: %w", err)
	}
	return oldValue.AiResponse, nil
}

// AddAiResponse adds u to the "ai_response" field.
func (m *UsageStatisticHourMutation) AddAiResponse(u int64) {
	if m.addai_response != nil {
		*m.addai_response += u
	} else {
		m.addai_response = &u
	}
}

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

// ResetAiResponse resets all changes to the "ai_response" field.
func (m *UsageStatisticHourMutation) ResetAiResponse() {
	m.ai_response = nil
	m.addai_response = nil
}

// SetSopRun sets the "sop_run" field.
func (m *UsageStatisticHourMutation) SetSopRun(u uint64) {
	m.sop_run = &u
	m.addsop_run = nil
}

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

// OldSopRun returns the old "sop_run" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldSopRun(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSopRun is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSopRun requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSopRun: %w", err)
	}
	return oldValue.SopRun, nil
}

// AddSopRun adds u to the "sop_run" field.
func (m *UsageStatisticHourMutation) AddSopRun(u int64) {
	if m.addsop_run != nil {
		*m.addsop_run += u
	} else {
		m.addsop_run = &u
	}
}

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

// ResetSopRun resets all changes to the "sop_run" field.
func (m *UsageStatisticHourMutation) ResetSopRun() {
	m.sop_run = nil
	m.addsop_run = nil
}

// SetTotalFriend sets the "total_friend" field.
func (m *UsageStatisticHourMutation) SetTotalFriend(u uint64) {
	m.total_friend = &u
	m.addtotal_friend = nil
}

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

// OldTotalFriend returns the old "total_friend" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldTotalFriend(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalFriend is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalFriend requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalFriend: %w", err)
	}
	return oldValue.TotalFriend, nil
}

// AddTotalFriend adds u to the "total_friend" field.
func (m *UsageStatisticHourMutation) AddTotalFriend(u int64) {
	if m.addtotal_friend != nil {
		*m.addtotal_friend += u
	} else {
		m.addtotal_friend = &u
	}
}

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

// ResetTotalFriend resets all changes to the "total_friend" field.
func (m *UsageStatisticHourMutation) ResetTotalFriend() {
	m.total_friend = nil
	m.addtotal_friend = nil
}

// SetTotalGroup sets the "total_group" field.
func (m *UsageStatisticHourMutation) SetTotalGroup(u uint64) {
	m.total_group = &u
	m.addtotal_group = nil
}

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

// OldTotalGroup returns the old "total_group" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldTotalGroup(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalGroup is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalGroup requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalGroup: %w", err)
	}
	return oldValue.TotalGroup, nil
}

// AddTotalGroup adds u to the "total_group" field.
func (m *UsageStatisticHourMutation) AddTotalGroup(u int64) {
	if m.addtotal_group != nil {
		*m.addtotal_group += u
	} else {
		m.addtotal_group = &u
	}
}

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

// ResetTotalGroup resets all changes to the "total_group" field.
func (m *UsageStatisticHourMutation) ResetTotalGroup() {
	m.total_group = nil
	m.addtotal_group = nil
}

// SetAccountBalance sets the "account_balance" field.
func (m *UsageStatisticHourMutation) SetAccountBalance(u uint64) {
	m.account_balance = &u
	m.addaccount_balance = nil
}

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

// OldAccountBalance returns the old "account_balance" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldAccountBalance(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAccountBalance is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAccountBalance requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAccountBalance: %w", err)
	}
	return oldValue.AccountBalance, nil
}

// AddAccountBalance adds u to the "account_balance" field.
func (m *UsageStatisticHourMutation) AddAccountBalance(u int64) {
	if m.addaccount_balance != nil {
		*m.addaccount_balance += u
	} else {
		m.addaccount_balance = &u
	}
}

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

// ResetAccountBalance resets all changes to the "account_balance" field.
func (m *UsageStatisticHourMutation) ResetAccountBalance() {
	m.account_balance = nil
	m.addaccount_balance = nil
}

// SetConsumeToken sets the "consume_token" field.
func (m *UsageStatisticHourMutation) SetConsumeToken(u uint64) {
	m.consume_token = &u
	m.addconsume_token = nil
}

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

// OldConsumeToken returns the old "consume_token" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldConsumeToken(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldConsumeToken is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldConsumeToken requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldConsumeToken: %w", err)
	}
	return oldValue.ConsumeToken, nil
}

// AddConsumeToken adds u to the "consume_token" field.
func (m *UsageStatisticHourMutation) AddConsumeToken(u int64) {
	if m.addconsume_token != nil {
		*m.addconsume_token += u
	} else {
		m.addconsume_token = &u
	}
}

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

// ResetConsumeToken resets all changes to the "consume_token" field.
func (m *UsageStatisticHourMutation) ResetConsumeToken() {
	m.consume_token = nil
	m.addconsume_token = nil
}

// SetActiveUser sets the "active_user" field.
func (m *UsageStatisticHourMutation) SetActiveUser(u uint64) {
	m.active_user = &u
	m.addactive_user = nil
}

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

// OldActiveUser returns the old "active_user" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldActiveUser(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldActiveUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldActiveUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldActiveUser: %w", err)
	}
	return oldValue.ActiveUser, nil
}

// AddActiveUser adds u to the "active_user" field.
func (m *UsageStatisticHourMutation) AddActiveUser(u int64) {
	if m.addactive_user != nil {
		*m.addactive_user += u
	} else {
		m.addactive_user = &u
	}
}

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

// ResetActiveUser resets all changes to the "active_user" field.
func (m *UsageStatisticHourMutation) ResetActiveUser() {
	m.active_user = nil
	m.addactive_user = nil
}

// SetNewUser sets the "new_user" field.
func (m *UsageStatisticHourMutation) SetNewUser(i int64) {
	m.new_user = &i
	m.addnew_user = nil
}

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

// OldNewUser returns the old "new_user" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldNewUser(ctx context.Context) (v int64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNewUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNewUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNewUser: %w", err)
	}
	return oldValue.NewUser, nil
}

// AddNewUser adds i to the "new_user" field.
func (m *UsageStatisticHourMutation) AddNewUser(i int64) {
	if m.addnew_user != nil {
		*m.addnew_user += i
	} else {
		m.addnew_user = &i
	}
}

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

// ResetNewUser resets all changes to the "new_user" field.
func (m *UsageStatisticHourMutation) ResetNewUser() {
	m.new_user = nil
	m.addnew_user = nil
}

// SetLabelDist sets the "label_dist" field.
func (m *UsageStatisticHourMutation) SetLabelDist(ctd []custom_types.LabelDist) {
	m.label_dist = &ctd
	m.appendlabel_dist = nil
}

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

// OldLabelDist returns the old "label_dist" field's value of the UsageStatisticHour entity.
// If the UsageStatisticHour object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticHourMutation) OldLabelDist(ctx context.Context) (v []custom_types.LabelDist, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldLabelDist is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldLabelDist requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldLabelDist: %w", err)
	}
	return oldValue.LabelDist, nil
}

// AppendLabelDist adds ctd to the "label_dist" field.
func (m *UsageStatisticHourMutation) AppendLabelDist(ctd []custom_types.LabelDist) {
	m.appendlabel_dist = append(m.appendlabel_dist, ctd...)
}

// AppendedLabelDist returns the list of values that were appended to the "label_dist" field in this mutation.
func (m *UsageStatisticHourMutation) AppendedLabelDist() ([]custom_types.LabelDist, bool) {
	if len(m.appendlabel_dist) == 0 {
		return nil, false
	}
	return m.appendlabel_dist, true
}

// ResetLabelDist resets all changes to the "label_dist" field.
func (m *UsageStatisticHourMutation) ResetLabelDist() {
	m.label_dist = nil
	m.appendlabel_dist = nil
}

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

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

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

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

// Type returns the node type of this mutation (UsageStatisticHour).
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) Fields() []string {
	fields := make([]string, 0, 17)
	if m.created_at != nil {
		fields = append(fields, usagestatistichour.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, usagestatistichour.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, usagestatistichour.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, usagestatistichour.FieldDeletedAt)
	}
	if m.addtime != nil {
		fields = append(fields, usagestatistichour.FieldAddtime)
	}
	if m._type != nil {
		fields = append(fields, usagestatistichour.FieldType)
	}
	if m.bot_id != nil {
		fields = append(fields, usagestatistichour.FieldBotID)
	}
	if m.organization_id != nil {
		fields = append(fields, usagestatistichour.FieldOrganizationID)
	}
	if m.ai_response != nil {
		fields = append(fields, usagestatistichour.FieldAiResponse)
	}
	if m.sop_run != nil {
		fields = append(fields, usagestatistichour.FieldSopRun)
	}
	if m.total_friend != nil {
		fields = append(fields, usagestatistichour.FieldTotalFriend)
	}
	if m.total_group != nil {
		fields = append(fields, usagestatistichour.FieldTotalGroup)
	}
	if m.account_balance != nil {
		fields = append(fields, usagestatistichour.FieldAccountBalance)
	}
	if m.consume_token != nil {
		fields = append(fields, usagestatistichour.FieldConsumeToken)
	}
	if m.active_user != nil {
		fields = append(fields, usagestatistichour.FieldActiveUser)
	}
	if m.new_user != nil {
		fields = append(fields, usagestatistichour.FieldNewUser)
	}
	if m.label_dist != nil {
		fields = append(fields, usagestatistichour.FieldLabelDist)
	}
	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 *UsageStatisticHourMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case usagestatistichour.FieldCreatedAt:
		return m.CreatedAt()
	case usagestatistichour.FieldUpdatedAt:
		return m.UpdatedAt()
	case usagestatistichour.FieldStatus:
		return m.Status()
	case usagestatistichour.FieldDeletedAt:
		return m.DeletedAt()
	case usagestatistichour.FieldAddtime:
		return m.Addtime()
	case usagestatistichour.FieldType:
		return m.GetType()
	case usagestatistichour.FieldBotID:
		return m.BotID()
	case usagestatistichour.FieldOrganizationID:
		return m.OrganizationID()
	case usagestatistichour.FieldAiResponse:
		return m.AiResponse()
	case usagestatistichour.FieldSopRun:
		return m.SopRun()
	case usagestatistichour.FieldTotalFriend:
		return m.TotalFriend()
	case usagestatistichour.FieldTotalGroup:
		return m.TotalGroup()
	case usagestatistichour.FieldAccountBalance:
		return m.AccountBalance()
	case usagestatistichour.FieldConsumeToken:
		return m.ConsumeToken()
	case usagestatistichour.FieldActiveUser:
		return m.ActiveUser()
	case usagestatistichour.FieldNewUser:
		return m.NewUser()
	case usagestatistichour.FieldLabelDist:
		return m.LabelDist()
	}
	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 *UsageStatisticHourMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case usagestatistichour.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case usagestatistichour.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case usagestatistichour.FieldStatus:
		return m.OldStatus(ctx)
	case usagestatistichour.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case usagestatistichour.FieldAddtime:
		return m.OldAddtime(ctx)
	case usagestatistichour.FieldType:
		return m.OldType(ctx)
	case usagestatistichour.FieldBotID:
		return m.OldBotID(ctx)
	case usagestatistichour.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case usagestatistichour.FieldAiResponse:
		return m.OldAiResponse(ctx)
	case usagestatistichour.FieldSopRun:
		return m.OldSopRun(ctx)
	case usagestatistichour.FieldTotalFriend:
		return m.OldTotalFriend(ctx)
	case usagestatistichour.FieldTotalGroup:
		return m.OldTotalGroup(ctx)
	case usagestatistichour.FieldAccountBalance:
		return m.OldAccountBalance(ctx)
	case usagestatistichour.FieldConsumeToken:
		return m.OldConsumeToken(ctx)
	case usagestatistichour.FieldActiveUser:
		return m.OldActiveUser(ctx)
	case usagestatistichour.FieldNewUser:
		return m.OldNewUser(ctx)
	case usagestatistichour.FieldLabelDist:
		return m.OldLabelDist(ctx)
	}
	return nil, fmt.Errorf("unknown UsageStatisticHour 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 *UsageStatisticHourMutation) SetField(name string, value ent.Value) error {
	switch name {
	case usagestatistichour.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 usagestatistichour.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 usagestatistichour.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case usagestatistichour.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 usagestatistichour.FieldAddtime:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAddtime(v)
		return nil
	case usagestatistichour.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case usagestatistichour.FieldBotID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case usagestatistichour.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case usagestatistichour.FieldAiResponse:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAiResponse(v)
		return nil
	case usagestatistichour.FieldSopRun:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSopRun(v)
		return nil
	case usagestatistichour.FieldTotalFriend:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalFriend(v)
		return nil
	case usagestatistichour.FieldTotalGroup:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalGroup(v)
		return nil
	case usagestatistichour.FieldAccountBalance:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccountBalance(v)
		return nil
	case usagestatistichour.FieldConsumeToken:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConsumeToken(v)
		return nil
	case usagestatistichour.FieldActiveUser:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActiveUser(v)
		return nil
	case usagestatistichour.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNewUser(v)
		return nil
	case usagestatistichour.FieldLabelDist:
		v, ok := value.([]custom_types.LabelDist)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLabelDist(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticHour field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsageStatisticHourMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, usagestatistichour.FieldStatus)
	}
	if m.addaddtime != nil {
		fields = append(fields, usagestatistichour.FieldAddtime)
	}
	if m.add_type != nil {
		fields = append(fields, usagestatistichour.FieldType)
	}
	if m.addorganization_id != nil {
		fields = append(fields, usagestatistichour.FieldOrganizationID)
	}
	if m.addai_response != nil {
		fields = append(fields, usagestatistichour.FieldAiResponse)
	}
	if m.addsop_run != nil {
		fields = append(fields, usagestatistichour.FieldSopRun)
	}
	if m.addtotal_friend != nil {
		fields = append(fields, usagestatistichour.FieldTotalFriend)
	}
	if m.addtotal_group != nil {
		fields = append(fields, usagestatistichour.FieldTotalGroup)
	}
	if m.addaccount_balance != nil {
		fields = append(fields, usagestatistichour.FieldAccountBalance)
	}
	if m.addconsume_token != nil {
		fields = append(fields, usagestatistichour.FieldConsumeToken)
	}
	if m.addactive_user != nil {
		fields = append(fields, usagestatistichour.FieldActiveUser)
	}
	if m.addnew_user != nil {
		fields = append(fields, usagestatistichour.FieldNewUser)
	}
	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 *UsageStatisticHourMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case usagestatistichour.FieldStatus:
		return m.AddedStatus()
	case usagestatistichour.FieldAddtime:
		return m.AddedAddtime()
	case usagestatistichour.FieldType:
		return m.AddedType()
	case usagestatistichour.FieldOrganizationID:
		return m.AddedOrganizationID()
	case usagestatistichour.FieldAiResponse:
		return m.AddedAiResponse()
	case usagestatistichour.FieldSopRun:
		return m.AddedSopRun()
	case usagestatistichour.FieldTotalFriend:
		return m.AddedTotalFriend()
	case usagestatistichour.FieldTotalGroup:
		return m.AddedTotalGroup()
	case usagestatistichour.FieldAccountBalance:
		return m.AddedAccountBalance()
	case usagestatistichour.FieldConsumeToken:
		return m.AddedConsumeToken()
	case usagestatistichour.FieldActiveUser:
		return m.AddedActiveUser()
	case usagestatistichour.FieldNewUser:
		return m.AddedNewUser()
	}
	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 *UsageStatisticHourMutation) AddField(name string, value ent.Value) error {
	switch name {
	case usagestatistichour.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case usagestatistichour.FieldAddtime:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAddtime(v)
		return nil
	case usagestatistichour.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case usagestatistichour.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case usagestatistichour.FieldAiResponse:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAiResponse(v)
		return nil
	case usagestatistichour.FieldSopRun:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSopRun(v)
		return nil
	case usagestatistichour.FieldTotalFriend:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalFriend(v)
		return nil
	case usagestatistichour.FieldTotalGroup:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalGroup(v)
		return nil
	case usagestatistichour.FieldAccountBalance:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAccountBalance(v)
		return nil
	case usagestatistichour.FieldConsumeToken:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConsumeToken(v)
		return nil
	case usagestatistichour.FieldActiveUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddActiveUser(v)
		return nil
	case usagestatistichour.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNewUser(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticHour numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsageStatisticHourMutation) 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 *UsageStatisticHourMutation) ClearField(name string) error {
	switch name {
	case usagestatistichour.FieldStatus:
		m.ClearStatus()
		return nil
	case usagestatistichour.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case usagestatistichour.FieldBotID:
		m.ClearBotID()
		return nil
	case usagestatistichour.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticHour 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 *UsageStatisticHourMutation) ResetField(name string) error {
	switch name {
	case usagestatistichour.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case usagestatistichour.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case usagestatistichour.FieldStatus:
		m.ResetStatus()
		return nil
	case usagestatistichour.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case usagestatistichour.FieldAddtime:
		m.ResetAddtime()
		return nil
	case usagestatistichour.FieldType:
		m.ResetType()
		return nil
	case usagestatistichour.FieldBotID:
		m.ResetBotID()
		return nil
	case usagestatistichour.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case usagestatistichour.FieldAiResponse:
		m.ResetAiResponse()
		return nil
	case usagestatistichour.FieldSopRun:
		m.ResetSopRun()
		return nil
	case usagestatistichour.FieldTotalFriend:
		m.ResetTotalFriend()
		return nil
	case usagestatistichour.FieldTotalGroup:
		m.ResetTotalGroup()
		return nil
	case usagestatistichour.FieldAccountBalance:
		m.ResetAccountBalance()
		return nil
	case usagestatistichour.FieldConsumeToken:
		m.ResetConsumeToken()
		return nil
	case usagestatistichour.FieldActiveUser:
		m.ResetActiveUser()
		return nil
	case usagestatistichour.FieldNewUser:
		m.ResetNewUser()
		return nil
	case usagestatistichour.FieldLabelDist:
		m.ResetLabelDist()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticHour field %s", name)
}

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

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

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

// UsageStatisticMonthMutation represents an operation that mutates the UsageStatisticMonth nodes in the graph.
type UsageStatisticMonthMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	status             *uint8
	addstatus          *int8
	deleted_at         *time.Time
	addtime            *uint64
	addaddtime         *int64
	_type              *int
	add_type           *int
	bot_id             *string
	organization_id    *uint64
	addorganization_id *int64
	ai_response        *uint64
	addai_response     *int64
	sop_run            *uint64
	addsop_run         *int64
	total_friend       *uint64
	addtotal_friend    *int64
	total_group        *uint64
	addtotal_group     *int64
	account_balance    *uint64
	addaccount_balance *int64
	consume_token      *uint64
	addconsume_token   *int64
	active_user        *uint64
	addactive_user     *int64
	new_user           *int64
	addnew_user        *int64
	label_dist         *[]custom_types.LabelDist
	appendlabel_dist   []custom_types.LabelDist
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*UsageStatisticMonth, error)
	predicates         []predicate.UsageStatisticMonth
}

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

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

// newUsageStatisticMonthMutation creates new mutation for the UsageStatisticMonth entity.
func newUsageStatisticMonthMutation(c config, op Op, opts ...usagestatisticmonthOption) *UsageStatisticMonthMutation {
	m := &UsageStatisticMonthMutation{
		config:        c,
		op:            op,
		typ:           TypeUsageStatisticMonth,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[usagestatisticmonth.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[usagestatisticmonth.FieldDeletedAt] = struct{}{}
}

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

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

// SetAddtime sets the "addtime" field.
func (m *UsageStatisticMonthMutation) SetAddtime(u uint64) {
	m.addtime = &u
	m.addaddtime = nil
}

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

// OldAddtime returns the old "addtime" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldAddtime(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAddtime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAddtime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAddtime: %w", err)
	}
	return oldValue.Addtime, nil
}

// AddAddtime adds u to the "addtime" field.
func (m *UsageStatisticMonthMutation) AddAddtime(u int64) {
	if m.addaddtime != nil {
		*m.addaddtime += u
	} else {
		m.addaddtime = &u
	}
}

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

// ResetAddtime resets all changes to the "addtime" field.
func (m *UsageStatisticMonthMutation) ResetAddtime() {
	m.addtime = nil
	m.addaddtime = nil
}

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

// GetType returns the value of the "type" field in the mutation.
func (m *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ResetType() {
	m._type = nil
	m.add_type = nil
}

// SetBotID sets the "bot_id" field.
func (m *UsageStatisticMonthMutation) SetBotID(s string) {
	m.bot_id = &s
}

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

// OldBotID returns the old "bot_id" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldBotID(ctx context.Context) (v string, 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
}

// ClearBotID clears the value of the "bot_id" field.
func (m *UsageStatisticMonthMutation) ClearBotID() {
	m.bot_id = nil
	m.clearedFields[usagestatisticmonth.FieldBotID] = struct{}{}
}

// BotIDCleared returns if the "bot_id" field was cleared in this mutation.
func (m *UsageStatisticMonthMutation) BotIDCleared() bool {
	_, ok := m.clearedFields[usagestatisticmonth.FieldBotID]
	return ok
}

// ResetBotID resets all changes to the "bot_id" field.
func (m *UsageStatisticMonthMutation) ResetBotID() {
	m.bot_id = nil
	delete(m.clearedFields, usagestatisticmonth.FieldBotID)
}

// SetOrganizationID sets the "organization_id" field.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[usagestatisticmonth.FieldOrganizationID] = struct{}{}
}

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

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

// SetAiResponse sets the "ai_response" field.
func (m *UsageStatisticMonthMutation) SetAiResponse(u uint64) {
	m.ai_response = &u
	m.addai_response = nil
}

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

// OldAiResponse returns the old "ai_response" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldAiResponse(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAiResponse is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAiResponse requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAiResponse: %w", err)
	}
	return oldValue.AiResponse, nil
}

// AddAiResponse adds u to the "ai_response" field.
func (m *UsageStatisticMonthMutation) AddAiResponse(u int64) {
	if m.addai_response != nil {
		*m.addai_response += u
	} else {
		m.addai_response = &u
	}
}

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

// ResetAiResponse resets all changes to the "ai_response" field.
func (m *UsageStatisticMonthMutation) ResetAiResponse() {
	m.ai_response = nil
	m.addai_response = nil
}

// SetSopRun sets the "sop_run" field.
func (m *UsageStatisticMonthMutation) SetSopRun(u uint64) {
	m.sop_run = &u
	m.addsop_run = nil
}

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

// OldSopRun returns the old "sop_run" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldSopRun(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSopRun is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSopRun requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSopRun: %w", err)
	}
	return oldValue.SopRun, nil
}

// AddSopRun adds u to the "sop_run" field.
func (m *UsageStatisticMonthMutation) AddSopRun(u int64) {
	if m.addsop_run != nil {
		*m.addsop_run += u
	} else {
		m.addsop_run = &u
	}
}

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

// ResetSopRun resets all changes to the "sop_run" field.
func (m *UsageStatisticMonthMutation) ResetSopRun() {
	m.sop_run = nil
	m.addsop_run = nil
}

// SetTotalFriend sets the "total_friend" field.
func (m *UsageStatisticMonthMutation) SetTotalFriend(u uint64) {
	m.total_friend = &u
	m.addtotal_friend = nil
}

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

// OldTotalFriend returns the old "total_friend" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldTotalFriend(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalFriend is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalFriend requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalFriend: %w", err)
	}
	return oldValue.TotalFriend, nil
}

// AddTotalFriend adds u to the "total_friend" field.
func (m *UsageStatisticMonthMutation) AddTotalFriend(u int64) {
	if m.addtotal_friend != nil {
		*m.addtotal_friend += u
	} else {
		m.addtotal_friend = &u
	}
}

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

// ResetTotalFriend resets all changes to the "total_friend" field.
func (m *UsageStatisticMonthMutation) ResetTotalFriend() {
	m.total_friend = nil
	m.addtotal_friend = nil
}

// SetTotalGroup sets the "total_group" field.
func (m *UsageStatisticMonthMutation) SetTotalGroup(u uint64) {
	m.total_group = &u
	m.addtotal_group = nil
}

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

// OldTotalGroup returns the old "total_group" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldTotalGroup(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalGroup is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalGroup requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalGroup: %w", err)
	}
	return oldValue.TotalGroup, nil
}

// AddTotalGroup adds u to the "total_group" field.
func (m *UsageStatisticMonthMutation) AddTotalGroup(u int64) {
	if m.addtotal_group != nil {
		*m.addtotal_group += u
	} else {
		m.addtotal_group = &u
	}
}

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

// ResetTotalGroup resets all changes to the "total_group" field.
func (m *UsageStatisticMonthMutation) ResetTotalGroup() {
	m.total_group = nil
	m.addtotal_group = nil
}

// SetAccountBalance sets the "account_balance" field.
func (m *UsageStatisticMonthMutation) SetAccountBalance(u uint64) {
	m.account_balance = &u
	m.addaccount_balance = nil
}

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

// OldAccountBalance returns the old "account_balance" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldAccountBalance(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAccountBalance is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAccountBalance requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAccountBalance: %w", err)
	}
	return oldValue.AccountBalance, nil
}

// AddAccountBalance adds u to the "account_balance" field.
func (m *UsageStatisticMonthMutation) AddAccountBalance(u int64) {
	if m.addaccount_balance != nil {
		*m.addaccount_balance += u
	} else {
		m.addaccount_balance = &u
	}
}

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

// ResetAccountBalance resets all changes to the "account_balance" field.
func (m *UsageStatisticMonthMutation) ResetAccountBalance() {
	m.account_balance = nil
	m.addaccount_balance = nil
}

// SetConsumeToken sets the "consume_token" field.
func (m *UsageStatisticMonthMutation) SetConsumeToken(u uint64) {
	m.consume_token = &u
	m.addconsume_token = nil
}

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

// OldConsumeToken returns the old "consume_token" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldConsumeToken(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldConsumeToken is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldConsumeToken requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldConsumeToken: %w", err)
	}
	return oldValue.ConsumeToken, nil
}

// AddConsumeToken adds u to the "consume_token" field.
func (m *UsageStatisticMonthMutation) AddConsumeToken(u int64) {
	if m.addconsume_token != nil {
		*m.addconsume_token += u
	} else {
		m.addconsume_token = &u
	}
}

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

// ResetConsumeToken resets all changes to the "consume_token" field.
func (m *UsageStatisticMonthMutation) ResetConsumeToken() {
	m.consume_token = nil
	m.addconsume_token = nil
}

// SetActiveUser sets the "active_user" field.
func (m *UsageStatisticMonthMutation) SetActiveUser(u uint64) {
	m.active_user = &u
	m.addactive_user = nil
}

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

// OldActiveUser returns the old "active_user" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldActiveUser(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldActiveUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldActiveUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldActiveUser: %w", err)
	}
	return oldValue.ActiveUser, nil
}

// AddActiveUser adds u to the "active_user" field.
func (m *UsageStatisticMonthMutation) AddActiveUser(u int64) {
	if m.addactive_user != nil {
		*m.addactive_user += u
	} else {
		m.addactive_user = &u
	}
}

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

// ResetActiveUser resets all changes to the "active_user" field.
func (m *UsageStatisticMonthMutation) ResetActiveUser() {
	m.active_user = nil
	m.addactive_user = nil
}

// SetNewUser sets the "new_user" field.
func (m *UsageStatisticMonthMutation) SetNewUser(i int64) {
	m.new_user = &i
	m.addnew_user = nil
}

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

// OldNewUser returns the old "new_user" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldNewUser(ctx context.Context) (v int64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNewUser is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNewUser requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNewUser: %w", err)
	}
	return oldValue.NewUser, nil
}

// AddNewUser adds i to the "new_user" field.
func (m *UsageStatisticMonthMutation) AddNewUser(i int64) {
	if m.addnew_user != nil {
		*m.addnew_user += i
	} else {
		m.addnew_user = &i
	}
}

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

// ResetNewUser resets all changes to the "new_user" field.
func (m *UsageStatisticMonthMutation) ResetNewUser() {
	m.new_user = nil
	m.addnew_user = nil
}

// SetLabelDist sets the "label_dist" field.
func (m *UsageStatisticMonthMutation) SetLabelDist(ctd []custom_types.LabelDist) {
	m.label_dist = &ctd
	m.appendlabel_dist = nil
}

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

// OldLabelDist returns the old "label_dist" field's value of the UsageStatisticMonth entity.
// If the UsageStatisticMonth object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageStatisticMonthMutation) OldLabelDist(ctx context.Context) (v []custom_types.LabelDist, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldLabelDist is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldLabelDist requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldLabelDist: %w", err)
	}
	return oldValue.LabelDist, nil
}

// AppendLabelDist adds ctd to the "label_dist" field.
func (m *UsageStatisticMonthMutation) AppendLabelDist(ctd []custom_types.LabelDist) {
	m.appendlabel_dist = append(m.appendlabel_dist, ctd...)
}

// AppendedLabelDist returns the list of values that were appended to the "label_dist" field in this mutation.
func (m *UsageStatisticMonthMutation) AppendedLabelDist() ([]custom_types.LabelDist, bool) {
	if len(m.appendlabel_dist) == 0 {
		return nil, false
	}
	return m.appendlabel_dist, true
}

// ResetLabelDist resets all changes to the "label_dist" field.
func (m *UsageStatisticMonthMutation) ResetLabelDist() {
	m.label_dist = nil
	m.appendlabel_dist = nil
}

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

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

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

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

// Type returns the node type of this mutation (UsageStatisticMonth).
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) Fields() []string {
	fields := make([]string, 0, 17)
	if m.created_at != nil {
		fields = append(fields, usagestatisticmonth.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, usagestatisticmonth.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, usagestatisticmonth.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, usagestatisticmonth.FieldDeletedAt)
	}
	if m.addtime != nil {
		fields = append(fields, usagestatisticmonth.FieldAddtime)
	}
	if m._type != nil {
		fields = append(fields, usagestatisticmonth.FieldType)
	}
	if m.bot_id != nil {
		fields = append(fields, usagestatisticmonth.FieldBotID)
	}
	if m.organization_id != nil {
		fields = append(fields, usagestatisticmonth.FieldOrganizationID)
	}
	if m.ai_response != nil {
		fields = append(fields, usagestatisticmonth.FieldAiResponse)
	}
	if m.sop_run != nil {
		fields = append(fields, usagestatisticmonth.FieldSopRun)
	}
	if m.total_friend != nil {
		fields = append(fields, usagestatisticmonth.FieldTotalFriend)
	}
	if m.total_group != nil {
		fields = append(fields, usagestatisticmonth.FieldTotalGroup)
	}
	if m.account_balance != nil {
		fields = append(fields, usagestatisticmonth.FieldAccountBalance)
	}
	if m.consume_token != nil {
		fields = append(fields, usagestatisticmonth.FieldConsumeToken)
	}
	if m.active_user != nil {
		fields = append(fields, usagestatisticmonth.FieldActiveUser)
	}
	if m.new_user != nil {
		fields = append(fields, usagestatisticmonth.FieldNewUser)
	}
	if m.label_dist != nil {
		fields = append(fields, usagestatisticmonth.FieldLabelDist)
	}
	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 *UsageStatisticMonthMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case usagestatisticmonth.FieldCreatedAt:
		return m.CreatedAt()
	case usagestatisticmonth.FieldUpdatedAt:
		return m.UpdatedAt()
	case usagestatisticmonth.FieldStatus:
		return m.Status()
	case usagestatisticmonth.FieldDeletedAt:
		return m.DeletedAt()
	case usagestatisticmonth.FieldAddtime:
		return m.Addtime()
	case usagestatisticmonth.FieldType:
		return m.GetType()
	case usagestatisticmonth.FieldBotID:
		return m.BotID()
	case usagestatisticmonth.FieldOrganizationID:
		return m.OrganizationID()
	case usagestatisticmonth.FieldAiResponse:
		return m.AiResponse()
	case usagestatisticmonth.FieldSopRun:
		return m.SopRun()
	case usagestatisticmonth.FieldTotalFriend:
		return m.TotalFriend()
	case usagestatisticmonth.FieldTotalGroup:
		return m.TotalGroup()
	case usagestatisticmonth.FieldAccountBalance:
		return m.AccountBalance()
	case usagestatisticmonth.FieldConsumeToken:
		return m.ConsumeToken()
	case usagestatisticmonth.FieldActiveUser:
		return m.ActiveUser()
	case usagestatisticmonth.FieldNewUser:
		return m.NewUser()
	case usagestatisticmonth.FieldLabelDist:
		return m.LabelDist()
	}
	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 *UsageStatisticMonthMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case usagestatisticmonth.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case usagestatisticmonth.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case usagestatisticmonth.FieldStatus:
		return m.OldStatus(ctx)
	case usagestatisticmonth.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case usagestatisticmonth.FieldAddtime:
		return m.OldAddtime(ctx)
	case usagestatisticmonth.FieldType:
		return m.OldType(ctx)
	case usagestatisticmonth.FieldBotID:
		return m.OldBotID(ctx)
	case usagestatisticmonth.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case usagestatisticmonth.FieldAiResponse:
		return m.OldAiResponse(ctx)
	case usagestatisticmonth.FieldSopRun:
		return m.OldSopRun(ctx)
	case usagestatisticmonth.FieldTotalFriend:
		return m.OldTotalFriend(ctx)
	case usagestatisticmonth.FieldTotalGroup:
		return m.OldTotalGroup(ctx)
	case usagestatisticmonth.FieldAccountBalance:
		return m.OldAccountBalance(ctx)
	case usagestatisticmonth.FieldConsumeToken:
		return m.OldConsumeToken(ctx)
	case usagestatisticmonth.FieldActiveUser:
		return m.OldActiveUser(ctx)
	case usagestatisticmonth.FieldNewUser:
		return m.OldNewUser(ctx)
	case usagestatisticmonth.FieldLabelDist:
		return m.OldLabelDist(ctx)
	}
	return nil, fmt.Errorf("unknown UsageStatisticMonth 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 *UsageStatisticMonthMutation) SetField(name string, value ent.Value) error {
	switch name {
	case usagestatisticmonth.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 usagestatisticmonth.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 usagestatisticmonth.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case usagestatisticmonth.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 usagestatisticmonth.FieldAddtime:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAddtime(v)
		return nil
	case usagestatisticmonth.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case usagestatisticmonth.FieldBotID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case usagestatisticmonth.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case usagestatisticmonth.FieldAiResponse:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAiResponse(v)
		return nil
	case usagestatisticmonth.FieldSopRun:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSopRun(v)
		return nil
	case usagestatisticmonth.FieldTotalFriend:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalFriend(v)
		return nil
	case usagestatisticmonth.FieldTotalGroup:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalGroup(v)
		return nil
	case usagestatisticmonth.FieldAccountBalance:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccountBalance(v)
		return nil
	case usagestatisticmonth.FieldConsumeToken:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConsumeToken(v)
		return nil
	case usagestatisticmonth.FieldActiveUser:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetActiveUser(v)
		return nil
	case usagestatisticmonth.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNewUser(v)
		return nil
	case usagestatisticmonth.FieldLabelDist:
		v, ok := value.([]custom_types.LabelDist)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLabelDist(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticMonth field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsageStatisticMonthMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, usagestatisticmonth.FieldStatus)
	}
	if m.addaddtime != nil {
		fields = append(fields, usagestatisticmonth.FieldAddtime)
	}
	if m.add_type != nil {
		fields = append(fields, usagestatisticmonth.FieldType)
	}
	if m.addorganization_id != nil {
		fields = append(fields, usagestatisticmonth.FieldOrganizationID)
	}
	if m.addai_response != nil {
		fields = append(fields, usagestatisticmonth.FieldAiResponse)
	}
	if m.addsop_run != nil {
		fields = append(fields, usagestatisticmonth.FieldSopRun)
	}
	if m.addtotal_friend != nil {
		fields = append(fields, usagestatisticmonth.FieldTotalFriend)
	}
	if m.addtotal_group != nil {
		fields = append(fields, usagestatisticmonth.FieldTotalGroup)
	}
	if m.addaccount_balance != nil {
		fields = append(fields, usagestatisticmonth.FieldAccountBalance)
	}
	if m.addconsume_token != nil {
		fields = append(fields, usagestatisticmonth.FieldConsumeToken)
	}
	if m.addactive_user != nil {
		fields = append(fields, usagestatisticmonth.FieldActiveUser)
	}
	if m.addnew_user != nil {
		fields = append(fields, usagestatisticmonth.FieldNewUser)
	}
	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 *UsageStatisticMonthMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case usagestatisticmonth.FieldStatus:
		return m.AddedStatus()
	case usagestatisticmonth.FieldAddtime:
		return m.AddedAddtime()
	case usagestatisticmonth.FieldType:
		return m.AddedType()
	case usagestatisticmonth.FieldOrganizationID:
		return m.AddedOrganizationID()
	case usagestatisticmonth.FieldAiResponse:
		return m.AddedAiResponse()
	case usagestatisticmonth.FieldSopRun:
		return m.AddedSopRun()
	case usagestatisticmonth.FieldTotalFriend:
		return m.AddedTotalFriend()
	case usagestatisticmonth.FieldTotalGroup:
		return m.AddedTotalGroup()
	case usagestatisticmonth.FieldAccountBalance:
		return m.AddedAccountBalance()
	case usagestatisticmonth.FieldConsumeToken:
		return m.AddedConsumeToken()
	case usagestatisticmonth.FieldActiveUser:
		return m.AddedActiveUser()
	case usagestatisticmonth.FieldNewUser:
		return m.AddedNewUser()
	}
	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 *UsageStatisticMonthMutation) AddField(name string, value ent.Value) error {
	switch name {
	case usagestatisticmonth.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case usagestatisticmonth.FieldAddtime:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAddtime(v)
		return nil
	case usagestatisticmonth.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case usagestatisticmonth.FieldOrganizationID:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOrganizationID(v)
		return nil
	case usagestatisticmonth.FieldAiResponse:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAiResponse(v)
		return nil
	case usagestatisticmonth.FieldSopRun:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSopRun(v)
		return nil
	case usagestatisticmonth.FieldTotalFriend:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalFriend(v)
		return nil
	case usagestatisticmonth.FieldTotalGroup:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalGroup(v)
		return nil
	case usagestatisticmonth.FieldAccountBalance:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddAccountBalance(v)
		return nil
	case usagestatisticmonth.FieldConsumeToken:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddConsumeToken(v)
		return nil
	case usagestatisticmonth.FieldActiveUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddActiveUser(v)
		return nil
	case usagestatisticmonth.FieldNewUser:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNewUser(v)
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticMonth numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsageStatisticMonthMutation) 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 *UsageStatisticMonthMutation) ClearField(name string) error {
	switch name {
	case usagestatisticmonth.FieldStatus:
		m.ClearStatus()
		return nil
	case usagestatisticmonth.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case usagestatisticmonth.FieldBotID:
		m.ClearBotID()
		return nil
	case usagestatisticmonth.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticMonth 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 *UsageStatisticMonthMutation) ResetField(name string) error {
	switch name {
	case usagestatisticmonth.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case usagestatisticmonth.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case usagestatisticmonth.FieldStatus:
		m.ResetStatus()
		return nil
	case usagestatisticmonth.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case usagestatisticmonth.FieldAddtime:
		m.ResetAddtime()
		return nil
	case usagestatisticmonth.FieldType:
		m.ResetType()
		return nil
	case usagestatisticmonth.FieldBotID:
		m.ResetBotID()
		return nil
	case usagestatisticmonth.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case usagestatisticmonth.FieldAiResponse:
		m.ResetAiResponse()
		return nil
	case usagestatisticmonth.FieldSopRun:
		m.ResetSopRun()
		return nil
	case usagestatisticmonth.FieldTotalFriend:
		m.ResetTotalFriend()
		return nil
	case usagestatisticmonth.FieldTotalGroup:
		m.ResetTotalGroup()
		return nil
	case usagestatisticmonth.FieldAccountBalance:
		m.ResetAccountBalance()
		return nil
	case usagestatisticmonth.FieldConsumeToken:
		m.ResetConsumeToken()
		return nil
	case usagestatisticmonth.FieldActiveUser:
		m.ResetActiveUser()
		return nil
	case usagestatisticmonth.FieldNewUser:
		m.ResetNewUser()
		return nil
	case usagestatisticmonth.FieldLabelDist:
		m.ResetLabelDist()
		return nil
	}
	return fmt.Errorf("unknown UsageStatisticMonth field %s", name)
}

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

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

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

// UsageTotalMutation represents an operation that mutates the UsageTotal nodes in the graph.
type UsageTotalMutation 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
	bot_id             *string
	total_tokens       *uint64
	addtotal_tokens    *int64
	start_index        *uint64
	addstart_index     *int64
	end_index          *uint64
	addend_index       *int64
	organization_id    *uint64
	addorganization_id *int64
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*UsageTotal, error)
	predicates         []predicate.UsageTotal
}

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

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

// newUsageTotalMutation creates new mutation for the UsageTotal entity.
func newUsageTotalMutation(c config, op Op, opts ...usagetotalOption) *UsageTotalMutation {
	m := &UsageTotalMutation{
		config:        c,
		op:            op,
		typ:           TypeUsageTotal,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UsageTotalMutation) 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 UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UsageTotalMutation) 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 UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *UsageTotalMutation) 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 UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[usagetotal.FieldStatus] = struct{}{}
}

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

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

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

// GetType returns the value of the "type" field in the mutation.
func (m *UsageTotalMutation) 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 UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) ClearType() {
	m._type = nil
	m.add_type = nil
	m.clearedFields[usagetotal.FieldType] = struct{}{}
}

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

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

// SetBotID sets the "bot_id" field.
func (m *UsageTotalMutation) SetBotID(s string) {
	m.bot_id = &s
}

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

// OldBotID returns the old "bot_id" field's value of the UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) OldBotID(ctx context.Context) (v string, 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
}

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

// SetTotalTokens sets the "total_tokens" field.
func (m *UsageTotalMutation) SetTotalTokens(u uint64) {
	m.total_tokens = &u
	m.addtotal_tokens = nil
}

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

// OldTotalTokens returns the old "total_tokens" field's value of the UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) OldTotalTokens(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTotalTokens is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTotalTokens requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTotalTokens: %w", err)
	}
	return oldValue.TotalTokens, nil
}

// AddTotalTokens adds u to the "total_tokens" field.
func (m *UsageTotalMutation) AddTotalTokens(u int64) {
	if m.addtotal_tokens != nil {
		*m.addtotal_tokens += u
	} else {
		m.addtotal_tokens = &u
	}
}

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

// ClearTotalTokens clears the value of the "total_tokens" field.
func (m *UsageTotalMutation) ClearTotalTokens() {
	m.total_tokens = nil
	m.addtotal_tokens = nil
	m.clearedFields[usagetotal.FieldTotalTokens] = struct{}{}
}

// TotalTokensCleared returns if the "total_tokens" field was cleared in this mutation.
func (m *UsageTotalMutation) TotalTokensCleared() bool {
	_, ok := m.clearedFields[usagetotal.FieldTotalTokens]
	return ok
}

// ResetTotalTokens resets all changes to the "total_tokens" field.
func (m *UsageTotalMutation) ResetTotalTokens() {
	m.total_tokens = nil
	m.addtotal_tokens = nil
	delete(m.clearedFields, usagetotal.FieldTotalTokens)
}

// SetStartIndex sets the "start_index" field.
func (m *UsageTotalMutation) SetStartIndex(u uint64) {
	m.start_index = &u
	m.addstart_index = nil
}

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

// OldStartIndex returns the old "start_index" field's value of the UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) OldStartIndex(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStartIndex is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStartIndex requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStartIndex: %w", err)
	}
	return oldValue.StartIndex, nil
}

// AddStartIndex adds u to the "start_index" field.
func (m *UsageTotalMutation) AddStartIndex(u int64) {
	if m.addstart_index != nil {
		*m.addstart_index += u
	} else {
		m.addstart_index = &u
	}
}

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

// ClearStartIndex clears the value of the "start_index" field.
func (m *UsageTotalMutation) ClearStartIndex() {
	m.start_index = nil
	m.addstart_index = nil
	m.clearedFields[usagetotal.FieldStartIndex] = struct{}{}
}

// StartIndexCleared returns if the "start_index" field was cleared in this mutation.
func (m *UsageTotalMutation) StartIndexCleared() bool {
	_, ok := m.clearedFields[usagetotal.FieldStartIndex]
	return ok
}

// ResetStartIndex resets all changes to the "start_index" field.
func (m *UsageTotalMutation) ResetStartIndex() {
	m.start_index = nil
	m.addstart_index = nil
	delete(m.clearedFields, usagetotal.FieldStartIndex)
}

// SetEndIndex sets the "end_index" field.
func (m *UsageTotalMutation) SetEndIndex(u uint64) {
	m.end_index = &u
	m.addend_index = nil
}

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

// OldEndIndex returns the old "end_index" field's value of the UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) OldEndIndex(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldEndIndex is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldEndIndex requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldEndIndex: %w", err)
	}
	return oldValue.EndIndex, nil
}

// AddEndIndex adds u to the "end_index" field.
func (m *UsageTotalMutation) AddEndIndex(u int64) {
	if m.addend_index != nil {
		*m.addend_index += u
	} else {
		m.addend_index = &u
	}
}

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

// ClearEndIndex clears the value of the "end_index" field.
func (m *UsageTotalMutation) ClearEndIndex() {
	m.end_index = nil
	m.addend_index = nil
	m.clearedFields[usagetotal.FieldEndIndex] = struct{}{}
}

// EndIndexCleared returns if the "end_index" field was cleared in this mutation.
func (m *UsageTotalMutation) EndIndexCleared() bool {
	_, ok := m.clearedFields[usagetotal.FieldEndIndex]
	return ok
}

// ResetEndIndex resets all changes to the "end_index" field.
func (m *UsageTotalMutation) ResetEndIndex() {
	m.end_index = nil
	m.addend_index = nil
	delete(m.clearedFields, usagetotal.FieldEndIndex)
}

// SetOrganizationID sets the "organization_id" field.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) 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 UsageTotal entity.
// If the UsageTotal object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) 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 *UsageTotalMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[usagetotal.FieldOrganizationID] = struct{}{}
}

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

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

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

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

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

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

// Type returns the node type of this mutation (UsageTotal).
func (m *UsageTotalMutation) 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 *UsageTotalMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, usagetotal.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, usagetotal.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, usagetotal.FieldStatus)
	}
	if m._type != nil {
		fields = append(fields, usagetotal.FieldType)
	}
	if m.bot_id != nil {
		fields = append(fields, usagetotal.FieldBotID)
	}
	if m.total_tokens != nil {
		fields = append(fields, usagetotal.FieldTotalTokens)
	}
	if m.start_index != nil {
		fields = append(fields, usagetotal.FieldStartIndex)
	}
	if m.end_index != nil {
		fields = append(fields, usagetotal.FieldEndIndex)
	}
	if m.organization_id != nil {
		fields = append(fields, usagetotal.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 *UsageTotalMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case usagetotal.FieldCreatedAt:
		return m.CreatedAt()
	case usagetotal.FieldUpdatedAt:
		return m.UpdatedAt()
	case usagetotal.FieldStatus:
		return m.Status()
	case usagetotal.FieldType:
		return m.GetType()
	case usagetotal.FieldBotID:
		return m.BotID()
	case usagetotal.FieldTotalTokens:
		return m.TotalTokens()
	case usagetotal.FieldStartIndex:
		return m.StartIndex()
	case usagetotal.FieldEndIndex:
		return m.EndIndex()
	case usagetotal.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 *UsageTotalMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case usagetotal.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case usagetotal.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case usagetotal.FieldStatus:
		return m.OldStatus(ctx)
	case usagetotal.FieldType:
		return m.OldType(ctx)
	case usagetotal.FieldBotID:
		return m.OldBotID(ctx)
	case usagetotal.FieldTotalTokens:
		return m.OldTotalTokens(ctx)
	case usagetotal.FieldStartIndex:
		return m.OldStartIndex(ctx)
	case usagetotal.FieldEndIndex:
		return m.OldEndIndex(ctx)
	case usagetotal.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	}
	return nil, fmt.Errorf("unknown UsageTotal 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 *UsageTotalMutation) SetField(name string, value ent.Value) error {
	switch name {
	case usagetotal.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 usagetotal.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 usagetotal.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case usagetotal.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	case usagetotal.FieldBotID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBotID(v)
		return nil
	case usagetotal.FieldTotalTokens:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTotalTokens(v)
		return nil
	case usagetotal.FieldStartIndex:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStartIndex(v)
		return nil
	case usagetotal.FieldEndIndex:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEndIndex(v)
		return nil
	case usagetotal.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 UsageTotal field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UsageTotalMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, usagetotal.FieldStatus)
	}
	if m.add_type != nil {
		fields = append(fields, usagetotal.FieldType)
	}
	if m.addtotal_tokens != nil {
		fields = append(fields, usagetotal.FieldTotalTokens)
	}
	if m.addstart_index != nil {
		fields = append(fields, usagetotal.FieldStartIndex)
	}
	if m.addend_index != nil {
		fields = append(fields, usagetotal.FieldEndIndex)
	}
	if m.addorganization_id != nil {
		fields = append(fields, usagetotal.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 *UsageTotalMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case usagetotal.FieldStatus:
		return m.AddedStatus()
	case usagetotal.FieldType:
		return m.AddedType()
	case usagetotal.FieldTotalTokens:
		return m.AddedTotalTokens()
	case usagetotal.FieldStartIndex:
		return m.AddedStartIndex()
	case usagetotal.FieldEndIndex:
		return m.AddedEndIndex()
	case usagetotal.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 *UsageTotalMutation) AddField(name string, value ent.Value) error {
	switch name {
	case usagetotal.FieldStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStatus(v)
		return nil
	case usagetotal.FieldType:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddType(v)
		return nil
	case usagetotal.FieldTotalTokens:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddTotalTokens(v)
		return nil
	case usagetotal.FieldStartIndex:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddStartIndex(v)
		return nil
	case usagetotal.FieldEndIndex:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddEndIndex(v)
		return nil
	case usagetotal.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 UsageTotal numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *UsageTotalMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(usagetotal.FieldStatus) {
		fields = append(fields, usagetotal.FieldStatus)
	}
	if m.FieldCleared(usagetotal.FieldType) {
		fields = append(fields, usagetotal.FieldType)
	}
	if m.FieldCleared(usagetotal.FieldTotalTokens) {
		fields = append(fields, usagetotal.FieldTotalTokens)
	}
	if m.FieldCleared(usagetotal.FieldStartIndex) {
		fields = append(fields, usagetotal.FieldStartIndex)
	}
	if m.FieldCleared(usagetotal.FieldEndIndex) {
		fields = append(fields, usagetotal.FieldEndIndex)
	}
	if m.FieldCleared(usagetotal.FieldOrganizationID) {
		fields = append(fields, usagetotal.FieldOrganizationID)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UsageTotalMutation) 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 *UsageTotalMutation) ClearField(name string) error {
	switch name {
	case usagetotal.FieldStatus:
		m.ClearStatus()
		return nil
	case usagetotal.FieldType:
		m.ClearType()
		return nil
	case usagetotal.FieldTotalTokens:
		m.ClearTotalTokens()
		return nil
	case usagetotal.FieldStartIndex:
		m.ClearStartIndex()
		return nil
	case usagetotal.FieldEndIndex:
		m.ClearEndIndex()
		return nil
	case usagetotal.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageTotal 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 *UsageTotalMutation) ResetField(name string) error {
	switch name {
	case usagetotal.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case usagetotal.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case usagetotal.FieldStatus:
		m.ResetStatus()
		return nil
	case usagetotal.FieldType:
		m.ResetType()
		return nil
	case usagetotal.FieldBotID:
		m.ResetBotID()
		return nil
	case usagetotal.FieldTotalTokens:
		m.ResetTotalTokens()
		return nil
	case usagetotal.FieldStartIndex:
		m.ResetStartIndex()
		return nil
	case usagetotal.FieldEndIndex:
		m.ResetEndIndex()
		return nil
	case usagetotal.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown UsageTotal field %s", name)
}

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

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

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

// WhatsappMutation represents an operation that mutates the Whatsapp nodes in the graph.
type WhatsappMutation struct {
	config
	op                     Op
	typ                    string
	id                     *uint64
	created_at             *time.Time
	updated_at             *time.Time
	status                 *uint8
	addstatus              *int8
	deleted_at             *time.Time
	wa_id                  *string
	wa_name                *string
	callback               *string
	account                *string
	cc                     *string
	phone                  *string
	cc_phone               *string
	phone_name             *string
	phone_status           *int8
	addphone_status        *int8
	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{}
	agent                  *uint64
	clearedagent           bool
	done                   bool
	oldValue               func(context.Context) (*Whatsapp, error)
	predicates             []predicate.Whatsapp
}

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

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

// newWhatsappMutation creates new mutation for the Whatsapp entity.
func newWhatsappMutation(c config, op Op, opts ...whatsappOption) *WhatsappMutation {
	m := &WhatsappMutation{
		config:        c,
		op:            op,
		typ:           TypeWhatsapp,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[whatsapp.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[whatsapp.FieldDeletedAt] = struct{}{}
}

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

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

// SetWaID sets the "wa_id" field.
func (m *WhatsappMutation) SetWaID(s string) {
	m.wa_id = &s
}

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

// OldWaID returns the old "wa_id" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldWaID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWaID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWaID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWaID: %w", err)
	}
	return oldValue.WaID, nil
}

// ClearWaID clears the value of the "wa_id" field.
func (m *WhatsappMutation) ClearWaID() {
	m.wa_id = nil
	m.clearedFields[whatsapp.FieldWaID] = struct{}{}
}

// WaIDCleared returns if the "wa_id" field was cleared in this mutation.
func (m *WhatsappMutation) WaIDCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldWaID]
	return ok
}

// ResetWaID resets all changes to the "wa_id" field.
func (m *WhatsappMutation) ResetWaID() {
	m.wa_id = nil
	delete(m.clearedFields, whatsapp.FieldWaID)
}

// SetWaName sets the "wa_name" field.
func (m *WhatsappMutation) SetWaName(s string) {
	m.wa_name = &s
}

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

// OldWaName returns the old "wa_name" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldWaName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWaName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWaName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWaName: %w", err)
	}
	return oldValue.WaName, nil
}

// ClearWaName clears the value of the "wa_name" field.
func (m *WhatsappMutation) ClearWaName() {
	m.wa_name = nil
	m.clearedFields[whatsapp.FieldWaName] = struct{}{}
}

// WaNameCleared returns if the "wa_name" field was cleared in this mutation.
func (m *WhatsappMutation) WaNameCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldWaName]
	return ok
}

// ResetWaName resets all changes to the "wa_name" field.
func (m *WhatsappMutation) ResetWaName() {
	m.wa_name = nil
	delete(m.clearedFields, whatsapp.FieldWaName)
}

// SetCallback sets the "callback" field.
func (m *WhatsappMutation) SetCallback(s string) {
	m.callback = &s
}

// Callback returns the value of the "callback" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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
}

// ClearCallback clears the value of the "callback" field.
func (m *WhatsappMutation) ClearCallback() {
	m.callback = nil
	m.clearedFields[whatsapp.FieldCallback] = struct{}{}
}

// CallbackCleared returns if the "callback" field was cleared in this mutation.
func (m *WhatsappMutation) CallbackCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldCallback]
	return ok
}

// ResetCallback resets all changes to the "callback" field.
func (m *WhatsappMutation) ResetCallback() {
	m.callback = nil
	delete(m.clearedFields, whatsapp.FieldCallback)
}

// SetAgentID sets the "agent_id" field.
func (m *WhatsappMutation) SetAgentID(u uint64) {
	m.agent = &u
}

// AgentID returns the value of the "agent_id" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ResetAgentID() {
	m.agent = nil
}

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

// Account returns the value of the "account" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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
}

// ClearAccount clears the value of the "account" field.
func (m *WhatsappMutation) ClearAccount() {
	m.account = nil
	m.clearedFields[whatsapp.FieldAccount] = struct{}{}
}

// AccountCleared returns if the "account" field was cleared in this mutation.
func (m *WhatsappMutation) AccountCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldAccount]
	return ok
}

// ResetAccount resets all changes to the "account" field.
func (m *WhatsappMutation) ResetAccount() {
	m.account = nil
	delete(m.clearedFields, whatsapp.FieldAccount)
}

// SetCc sets the "cc" field.
func (m *WhatsappMutation) SetCc(s string) {
	m.cc = &s
}

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

// OldCc returns the old "cc" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldCc(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCc is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCc requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCc: %w", err)
	}
	return oldValue.Cc, nil
}

// ResetCc resets all changes to the "cc" field.
func (m *WhatsappMutation) ResetCc() {
	m.cc = nil
}

// SetPhone sets the "phone" field.
func (m *WhatsappMutation) SetPhone(s string) {
	m.phone = &s
}

// Phone returns the value of the "phone" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ResetPhone() {
	m.phone = nil
}

// SetCcPhone sets the "cc_phone" field.
func (m *WhatsappMutation) SetCcPhone(s string) {
	m.cc_phone = &s
}

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

// OldCcPhone returns the old "cc_phone" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldCcPhone(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCcPhone is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldCcPhone requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCcPhone: %w", err)
	}
	return oldValue.CcPhone, nil
}

// ResetCcPhone resets all changes to the "cc_phone" field.
func (m *WhatsappMutation) ResetCcPhone() {
	m.cc_phone = nil
}

// SetPhoneName sets the "phone_name" field.
func (m *WhatsappMutation) SetPhoneName(s string) {
	m.phone_name = &s
}

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

// OldPhoneName returns the old "phone_name" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldPhoneName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPhoneName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPhoneName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPhoneName: %w", err)
	}
	return oldValue.PhoneName, nil
}

// ResetPhoneName resets all changes to the "phone_name" field.
func (m *WhatsappMutation) ResetPhoneName() {
	m.phone_name = nil
}

// SetPhoneStatus sets the "phone_status" field.
func (m *WhatsappMutation) SetPhoneStatus(i int8) {
	m.phone_status = &i
	m.addphone_status = nil
}

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

// OldPhoneStatus returns the old "phone_status" field's value of the Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) OldPhoneStatus(ctx context.Context) (v int8, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldPhoneStatus is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldPhoneStatus requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPhoneStatus: %w", err)
	}
	return oldValue.PhoneStatus, nil
}

// AddPhoneStatus adds i to the "phone_status" field.
func (m *WhatsappMutation) AddPhoneStatus(i int8) {
	if m.addphone_status != nil {
		*m.addphone_status += i
	} else {
		m.addphone_status = &i
	}
}

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

// ResetPhoneStatus resets all changes to the "phone_status" field.
func (m *WhatsappMutation) ResetPhoneStatus() {
	m.phone_status = nil
	m.addphone_status = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[whatsapp.FieldOrganizationID] = struct{}{}
}

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

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

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

// APIBase returns the value of the "api_base" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ClearAPIBase() {
	m.api_base = nil
	m.clearedFields[whatsapp.FieldAPIBase] = struct{}{}
}

// APIBaseCleared returns if the "api_base" field was cleared in this mutation.
func (m *WhatsappMutation) APIBaseCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldAPIBase]
	return ok
}

// ResetAPIBase resets all changes to the "api_base" field.
func (m *WhatsappMutation) ResetAPIBase() {
	m.api_base = nil
	delete(m.clearedFields, whatsapp.FieldAPIBase)
}

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

// APIKey returns the value of the "api_key" field in the mutation.
func (m *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) ClearAPIKey() {
	m.api_key = nil
	m.clearedFields[whatsapp.FieldAPIKey] = struct{}{}
}

// APIKeyCleared returns if the "api_key" field was cleared in this mutation.
func (m *WhatsappMutation) APIKeyCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldAPIKey]
	return ok
}

// ResetAPIKey resets all changes to the "api_key" field.
func (m *WhatsappMutation) ResetAPIKey() {
	m.api_key = nil
	delete(m.clearedFields, whatsapp.FieldAPIKey)
}

// SetAllowList sets the "allow_list" field.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) AppendedAllowList() ([]string, bool) {
	if len(m.appendallow_list) == 0 {
		return nil, false
	}
	return m.appendallow_list, true
}

// ClearAllowList clears the value of the "allow_list" field.
func (m *WhatsappMutation) ClearAllowList() {
	m.allow_list = nil
	m.appendallow_list = nil
	m.clearedFields[whatsapp.FieldAllowList] = struct{}{}
}

// AllowListCleared returns if the "allow_list" field was cleared in this mutation.
func (m *WhatsappMutation) AllowListCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldAllowList]
	return ok
}

// ResetAllowList resets all changes to the "allow_list" field.
func (m *WhatsappMutation) ResetAllowList() {
	m.allow_list = nil
	m.appendallow_list = nil
	delete(m.clearedFields, whatsapp.FieldAllowList)
}

// SetGroupAllowList sets the "group_allow_list" field.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) AppendedGroupAllowList() ([]string, bool) {
	if len(m.appendgroup_allow_list) == 0 {
		return nil, false
	}
	return m.appendgroup_allow_list, true
}

// ClearGroupAllowList clears the value of the "group_allow_list" field.
func (m *WhatsappMutation) ClearGroupAllowList() {
	m.group_allow_list = nil
	m.appendgroup_allow_list = nil
	m.clearedFields[whatsapp.FieldGroupAllowList] = struct{}{}
}

// GroupAllowListCleared returns if the "group_allow_list" field was cleared in this mutation.
func (m *WhatsappMutation) GroupAllowListCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldGroupAllowList]
	return ok
}

// ResetGroupAllowList resets all changes to the "group_allow_list" field.
func (m *WhatsappMutation) ResetGroupAllowList() {
	m.group_allow_list = nil
	m.appendgroup_allow_list = nil
	delete(m.clearedFields, whatsapp.FieldGroupAllowList)
}

// SetBlockList sets the "block_list" field.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) AppendedBlockList() ([]string, bool) {
	if len(m.appendblock_list) == 0 {
		return nil, false
	}
	return m.appendblock_list, true
}

// ClearBlockList clears the value of the "block_list" field.
func (m *WhatsappMutation) ClearBlockList() {
	m.block_list = nil
	m.appendblock_list = nil
	m.clearedFields[whatsapp.FieldBlockList] = struct{}{}
}

// BlockListCleared returns if the "block_list" field was cleared in this mutation.
func (m *WhatsappMutation) BlockListCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldBlockList]
	return ok
}

// ResetBlockList resets all changes to the "block_list" field.
func (m *WhatsappMutation) ResetBlockList() {
	m.block_list = nil
	m.appendblock_list = nil
	delete(m.clearedFields, whatsapp.FieldBlockList)
}

// SetGroupBlockList sets the "group_block_list" field.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 Whatsapp entity.
// If the Whatsapp object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappMutation) 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 *WhatsappMutation) 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 *WhatsappMutation) AppendedGroupBlockList() ([]string, bool) {
	if len(m.appendgroup_block_list) == 0 {
		return nil, false
	}
	return m.appendgroup_block_list, true
}

// ClearGroupBlockList clears the value of the "group_block_list" field.
func (m *WhatsappMutation) ClearGroupBlockList() {
	m.group_block_list = nil
	m.appendgroup_block_list = nil
	m.clearedFields[whatsapp.FieldGroupBlockList] = struct{}{}
}

// GroupBlockListCleared returns if the "group_block_list" field was cleared in this mutation.
func (m *WhatsappMutation) GroupBlockListCleared() bool {
	_, ok := m.clearedFields[whatsapp.FieldGroupBlockList]
	return ok
}

// ResetGroupBlockList resets all changes to the "group_block_list" field.
func (m *WhatsappMutation) ResetGroupBlockList() {
	m.group_block_list = nil
	m.appendgroup_block_list = nil
	delete(m.clearedFields, whatsapp.FieldGroupBlockList)
}

// ClearAgent clears the "agent" edge to the Agent entity.
func (m *WhatsappMutation) ClearAgent() {
	m.clearedagent = true
	m.clearedFields[whatsapp.FieldAgentID] = struct{}{}
}

// AgentCleared reports if the "agent" edge to the Agent entity was cleared.
func (m *WhatsappMutation) 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 *WhatsappMutation) AgentIDs() (ids []uint64) {
	if id := m.agent; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetAgent resets all changes to the "agent" edge.
func (m *WhatsappMutation) ResetAgent() {
	m.agent = nil
	m.clearedagent = false
}

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

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

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

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

// Type returns the node type of this mutation (Whatsapp).
func (m *WhatsappMutation) 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 *WhatsappMutation) Fields() []string {
	fields := make([]string, 0, 21)
	if m.created_at != nil {
		fields = append(fields, whatsapp.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, whatsapp.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, whatsapp.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, whatsapp.FieldDeletedAt)
	}
	if m.wa_id != nil {
		fields = append(fields, whatsapp.FieldWaID)
	}
	if m.wa_name != nil {
		fields = append(fields, whatsapp.FieldWaName)
	}
	if m.callback != nil {
		fields = append(fields, whatsapp.FieldCallback)
	}
	if m.agent != nil {
		fields = append(fields, whatsapp.FieldAgentID)
	}
	if m.account != nil {
		fields = append(fields, whatsapp.FieldAccount)
	}
	if m.cc != nil {
		fields = append(fields, whatsapp.FieldCc)
	}
	if m.phone != nil {
		fields = append(fields, whatsapp.FieldPhone)
	}
	if m.cc_phone != nil {
		fields = append(fields, whatsapp.FieldCcPhone)
	}
	if m.phone_name != nil {
		fields = append(fields, whatsapp.FieldPhoneName)
	}
	if m.phone_status != nil {
		fields = append(fields, whatsapp.FieldPhoneStatus)
	}
	if m.organization_id != nil {
		fields = append(fields, whatsapp.FieldOrganizationID)
	}
	if m.api_base != nil {
		fields = append(fields, whatsapp.FieldAPIBase)
	}
	if m.api_key != nil {
		fields = append(fields, whatsapp.FieldAPIKey)
	}
	if m.allow_list != nil {
		fields = append(fields, whatsapp.FieldAllowList)
	}
	if m.group_allow_list != nil {
		fields = append(fields, whatsapp.FieldGroupAllowList)
	}
	if m.block_list != nil {
		fields = append(fields, whatsapp.FieldBlockList)
	}
	if m.group_block_list != nil {
		fields = append(fields, whatsapp.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 *WhatsappMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case whatsapp.FieldCreatedAt:
		return m.CreatedAt()
	case whatsapp.FieldUpdatedAt:
		return m.UpdatedAt()
	case whatsapp.FieldStatus:
		return m.Status()
	case whatsapp.FieldDeletedAt:
		return m.DeletedAt()
	case whatsapp.FieldWaID:
		return m.WaID()
	case whatsapp.FieldWaName:
		return m.WaName()
	case whatsapp.FieldCallback:
		return m.Callback()
	case whatsapp.FieldAgentID:
		return m.AgentID()
	case whatsapp.FieldAccount:
		return m.Account()
	case whatsapp.FieldCc:
		return m.Cc()
	case whatsapp.FieldPhone:
		return m.Phone()
	case whatsapp.FieldCcPhone:
		return m.CcPhone()
	case whatsapp.FieldPhoneName:
		return m.PhoneName()
	case whatsapp.FieldPhoneStatus:
		return m.PhoneStatus()
	case whatsapp.FieldOrganizationID:
		return m.OrganizationID()
	case whatsapp.FieldAPIBase:
		return m.APIBase()
	case whatsapp.FieldAPIKey:
		return m.APIKey()
	case whatsapp.FieldAllowList:
		return m.AllowList()
	case whatsapp.FieldGroupAllowList:
		return m.GroupAllowList()
	case whatsapp.FieldBlockList:
		return m.BlockList()
	case whatsapp.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 *WhatsappMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case whatsapp.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case whatsapp.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case whatsapp.FieldStatus:
		return m.OldStatus(ctx)
	case whatsapp.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case whatsapp.FieldWaID:
		return m.OldWaID(ctx)
	case whatsapp.FieldWaName:
		return m.OldWaName(ctx)
	case whatsapp.FieldCallback:
		return m.OldCallback(ctx)
	case whatsapp.FieldAgentID:
		return m.OldAgentID(ctx)
	case whatsapp.FieldAccount:
		return m.OldAccount(ctx)
	case whatsapp.FieldCc:
		return m.OldCc(ctx)
	case whatsapp.FieldPhone:
		return m.OldPhone(ctx)
	case whatsapp.FieldCcPhone:
		return m.OldCcPhone(ctx)
	case whatsapp.FieldPhoneName:
		return m.OldPhoneName(ctx)
	case whatsapp.FieldPhoneStatus:
		return m.OldPhoneStatus(ctx)
	case whatsapp.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case whatsapp.FieldAPIBase:
		return m.OldAPIBase(ctx)
	case whatsapp.FieldAPIKey:
		return m.OldAPIKey(ctx)
	case whatsapp.FieldAllowList:
		return m.OldAllowList(ctx)
	case whatsapp.FieldGroupAllowList:
		return m.OldGroupAllowList(ctx)
	case whatsapp.FieldBlockList:
		return m.OldBlockList(ctx)
	case whatsapp.FieldGroupBlockList:
		return m.OldGroupBlockList(ctx)
	}
	return nil, fmt.Errorf("unknown Whatsapp 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 *WhatsappMutation) SetField(name string, value ent.Value) error {
	switch name {
	case whatsapp.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 whatsapp.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 whatsapp.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case whatsapp.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 whatsapp.FieldWaID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWaID(v)
		return nil
	case whatsapp.FieldWaName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWaName(v)
		return nil
	case whatsapp.FieldCallback:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCallback(v)
		return nil
	case whatsapp.FieldAgentID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAgentID(v)
		return nil
	case whatsapp.FieldAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAccount(v)
		return nil
	case whatsapp.FieldCc:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCc(v)
		return nil
	case whatsapp.FieldPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhone(v)
		return nil
	case whatsapp.FieldCcPhone:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCcPhone(v)
		return nil
	case whatsapp.FieldPhoneName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhoneName(v)
		return nil
	case whatsapp.FieldPhoneStatus:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPhoneStatus(v)
		return nil
	case whatsapp.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case whatsapp.FieldAPIBase:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIBase(v)
		return nil
	case whatsapp.FieldAPIKey:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAPIKey(v)
		return nil
	case whatsapp.FieldAllowList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAllowList(v)
		return nil
	case whatsapp.FieldGroupAllowList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGroupAllowList(v)
		return nil
	case whatsapp.FieldBlockList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBlockList(v)
		return nil
	case whatsapp.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 Whatsapp field %s", name)
}

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

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WhatsappMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(whatsapp.FieldStatus) {
		fields = append(fields, whatsapp.FieldStatus)
	}
	if m.FieldCleared(whatsapp.FieldDeletedAt) {
		fields = append(fields, whatsapp.FieldDeletedAt)
	}
	if m.FieldCleared(whatsapp.FieldWaID) {
		fields = append(fields, whatsapp.FieldWaID)
	}
	if m.FieldCleared(whatsapp.FieldWaName) {
		fields = append(fields, whatsapp.FieldWaName)
	}
	if m.FieldCleared(whatsapp.FieldCallback) {
		fields = append(fields, whatsapp.FieldCallback)
	}
	if m.FieldCleared(whatsapp.FieldAccount) {
		fields = append(fields, whatsapp.FieldAccount)
	}
	if m.FieldCleared(whatsapp.FieldOrganizationID) {
		fields = append(fields, whatsapp.FieldOrganizationID)
	}
	if m.FieldCleared(whatsapp.FieldAPIBase) {
		fields = append(fields, whatsapp.FieldAPIBase)
	}
	if m.FieldCleared(whatsapp.FieldAPIKey) {
		fields = append(fields, whatsapp.FieldAPIKey)
	}
	if m.FieldCleared(whatsapp.FieldAllowList) {
		fields = append(fields, whatsapp.FieldAllowList)
	}
	if m.FieldCleared(whatsapp.FieldGroupAllowList) {
		fields = append(fields, whatsapp.FieldGroupAllowList)
	}
	if m.FieldCleared(whatsapp.FieldBlockList) {
		fields = append(fields, whatsapp.FieldBlockList)
	}
	if m.FieldCleared(whatsapp.FieldGroupBlockList) {
		fields = append(fields, whatsapp.FieldGroupBlockList)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WhatsappMutation) 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 *WhatsappMutation) ClearField(name string) error {
	switch name {
	case whatsapp.FieldStatus:
		m.ClearStatus()
		return nil
	case whatsapp.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case whatsapp.FieldWaID:
		m.ClearWaID()
		return nil
	case whatsapp.FieldWaName:
		m.ClearWaName()
		return nil
	case whatsapp.FieldCallback:
		m.ClearCallback()
		return nil
	case whatsapp.FieldAccount:
		m.ClearAccount()
		return nil
	case whatsapp.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	case whatsapp.FieldAPIBase:
		m.ClearAPIBase()
		return nil
	case whatsapp.FieldAPIKey:
		m.ClearAPIKey()
		return nil
	case whatsapp.FieldAllowList:
		m.ClearAllowList()
		return nil
	case whatsapp.FieldGroupAllowList:
		m.ClearGroupAllowList()
		return nil
	case whatsapp.FieldBlockList:
		m.ClearBlockList()
		return nil
	case whatsapp.FieldGroupBlockList:
		m.ClearGroupBlockList()
		return nil
	}
	return fmt.Errorf("unknown Whatsapp 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 *WhatsappMutation) ResetField(name string) error {
	switch name {
	case whatsapp.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case whatsapp.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case whatsapp.FieldStatus:
		m.ResetStatus()
		return nil
	case whatsapp.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case whatsapp.FieldWaID:
		m.ResetWaID()
		return nil
	case whatsapp.FieldWaName:
		m.ResetWaName()
		return nil
	case whatsapp.FieldCallback:
		m.ResetCallback()
		return nil
	case whatsapp.FieldAgentID:
		m.ResetAgentID()
		return nil
	case whatsapp.FieldAccount:
		m.ResetAccount()
		return nil
	case whatsapp.FieldCc:
		m.ResetCc()
		return nil
	case whatsapp.FieldPhone:
		m.ResetPhone()
		return nil
	case whatsapp.FieldCcPhone:
		m.ResetCcPhone()
		return nil
	case whatsapp.FieldPhoneName:
		m.ResetPhoneName()
		return nil
	case whatsapp.FieldPhoneStatus:
		m.ResetPhoneStatus()
		return nil
	case whatsapp.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case whatsapp.FieldAPIBase:
		m.ResetAPIBase()
		return nil
	case whatsapp.FieldAPIKey:
		m.ResetAPIKey()
		return nil
	case whatsapp.FieldAllowList:
		m.ResetAllowList()
		return nil
	case whatsapp.FieldGroupAllowList:
		m.ResetGroupAllowList()
		return nil
	case whatsapp.FieldBlockList:
		m.ResetBlockList()
		return nil
	case whatsapp.FieldGroupBlockList:
		m.ResetGroupBlockList()
		return nil
	}
	return fmt.Errorf("unknown Whatsapp field %s", name)
}

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

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WhatsappMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case whatsapp.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 *WhatsappMutation) 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 *WhatsappMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

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

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

// WhatsappChannelMutation represents an operation that mutates the WhatsappChannel nodes in the graph.
type WhatsappChannelMutation struct {
	config
	op                 Op
	typ                string
	id                 *uint64
	created_at         *time.Time
	updated_at         *time.Time
	status             *uint8
	addstatus          *int8
	deleted_at         *time.Time
	ak                 *string
	sk                 *string
	wa_id              *string
	wa_name            *string
	waba_id            *uint64
	addwaba_id         *int64
	business_id        *uint64
	addbusiness_id     *int64
	organization_id    *uint64
	addorganization_id *int64
	verify_account     *string
	clearedFields      map[string]struct{}
	done               bool
	oldValue           func(context.Context) (*WhatsappChannel, error)
	predicates         []predicate.WhatsappChannel
}

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

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

// newWhatsappChannelMutation creates new mutation for the WhatsappChannel entity.
func newWhatsappChannelMutation(c config, op Op, opts ...whatsappchannelOption) *WhatsappChannelMutation {
	m := &WhatsappChannelMutation{
		config:        c,
		op:            op,
		typ:           TypeWhatsappChannel,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WhatsappChannelMutation) 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 WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *WhatsappChannelMutation) 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 WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *WhatsappChannelMutation) 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 WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) 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 *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[whatsappchannel.FieldStatus] = struct{}{}
}

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

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

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

// DeletedAt returns the value of the "deleted_at" field in the mutation.
func (m *WhatsappChannelMutation) 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 WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[whatsappchannel.FieldDeletedAt] = struct{}{}
}

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

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

// SetAk sets the "ak" field.
func (m *WhatsappChannelMutation) SetAk(s string) {
	m.ak = &s
}

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

// OldAk returns the old "ak" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldAk(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldAk is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldAk requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldAk: %w", err)
	}
	return oldValue.Ak, nil
}

// ClearAk clears the value of the "ak" field.
func (m *WhatsappChannelMutation) ClearAk() {
	m.ak = nil
	m.clearedFields[whatsappchannel.FieldAk] = struct{}{}
}

// AkCleared returns if the "ak" field was cleared in this mutation.
func (m *WhatsappChannelMutation) AkCleared() bool {
	_, ok := m.clearedFields[whatsappchannel.FieldAk]
	return ok
}

// ResetAk resets all changes to the "ak" field.
func (m *WhatsappChannelMutation) ResetAk() {
	m.ak = nil
	delete(m.clearedFields, whatsappchannel.FieldAk)
}

// SetSk sets the "sk" field.
func (m *WhatsappChannelMutation) SetSk(s string) {
	m.sk = &s
}

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

// OldSk returns the old "sk" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldSk(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldSk is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldSk requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldSk: %w", err)
	}
	return oldValue.Sk, nil
}

// ResetSk resets all changes to the "sk" field.
func (m *WhatsappChannelMutation) ResetSk() {
	m.sk = nil
}

// SetWaID sets the "wa_id" field.
func (m *WhatsappChannelMutation) SetWaID(s string) {
	m.wa_id = &s
}

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

// OldWaID returns the old "wa_id" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldWaID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWaID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWaID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWaID: %w", err)
	}
	return oldValue.WaID, nil
}

// ClearWaID clears the value of the "wa_id" field.
func (m *WhatsappChannelMutation) ClearWaID() {
	m.wa_id = nil
	m.clearedFields[whatsappchannel.FieldWaID] = struct{}{}
}

// WaIDCleared returns if the "wa_id" field was cleared in this mutation.
func (m *WhatsappChannelMutation) WaIDCleared() bool {
	_, ok := m.clearedFields[whatsappchannel.FieldWaID]
	return ok
}

// ResetWaID resets all changes to the "wa_id" field.
func (m *WhatsappChannelMutation) ResetWaID() {
	m.wa_id = nil
	delete(m.clearedFields, whatsappchannel.FieldWaID)
}

// SetWaName sets the "wa_name" field.
func (m *WhatsappChannelMutation) SetWaName(s string) {
	m.wa_name = &s
}

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

// OldWaName returns the old "wa_name" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldWaName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWaName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWaName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWaName: %w", err)
	}
	return oldValue.WaName, nil
}

// ClearWaName clears the value of the "wa_name" field.
func (m *WhatsappChannelMutation) ClearWaName() {
	m.wa_name = nil
	m.clearedFields[whatsappchannel.FieldWaName] = struct{}{}
}

// WaNameCleared returns if the "wa_name" field was cleared in this mutation.
func (m *WhatsappChannelMutation) WaNameCleared() bool {
	_, ok := m.clearedFields[whatsappchannel.FieldWaName]
	return ok
}

// ResetWaName resets all changes to the "wa_name" field.
func (m *WhatsappChannelMutation) ResetWaName() {
	m.wa_name = nil
	delete(m.clearedFields, whatsappchannel.FieldWaName)
}

// SetWabaID sets the "waba_id" field.
func (m *WhatsappChannelMutation) SetWabaID(u uint64) {
	m.waba_id = &u
	m.addwaba_id = nil
}

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

// OldWabaID returns the old "waba_id" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldWabaID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldWabaID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldWabaID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldWabaID: %w", err)
	}
	return oldValue.WabaID, nil
}

// AddWabaID adds u to the "waba_id" field.
func (m *WhatsappChannelMutation) AddWabaID(u int64) {
	if m.addwaba_id != nil {
		*m.addwaba_id += u
	} else {
		m.addwaba_id = &u
	}
}

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

// ResetWabaID resets all changes to the "waba_id" field.
func (m *WhatsappChannelMutation) ResetWabaID() {
	m.waba_id = nil
	m.addwaba_id = nil
}

// SetBusinessID sets the "business_id" field.
func (m *WhatsappChannelMutation) SetBusinessID(u uint64) {
	m.business_id = &u
	m.addbusiness_id = nil
}

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

// OldBusinessID returns the old "business_id" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldBusinessID(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBusinessID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBusinessID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBusinessID: %w", err)
	}
	return oldValue.BusinessID, nil
}

// AddBusinessID adds u to the "business_id" field.
func (m *WhatsappChannelMutation) AddBusinessID(u int64) {
	if m.addbusiness_id != nil {
		*m.addbusiness_id += u
	} else {
		m.addbusiness_id = &u
	}
}

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

// ResetBusinessID resets all changes to the "business_id" field.
func (m *WhatsappChannelMutation) ResetBusinessID() {
	m.business_id = nil
	m.addbusiness_id = nil
}

// SetOrganizationID sets the "organization_id" field.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) 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 WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) 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 *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ClearOrganizationID() {
	m.organization_id = nil
	m.addorganization_id = nil
	m.clearedFields[whatsappchannel.FieldOrganizationID] = struct{}{}
}

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

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

// SetVerifyAccount sets the "verify_account" field.
func (m *WhatsappChannelMutation) SetVerifyAccount(s string) {
	m.verify_account = &s
}

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

// OldVerifyAccount returns the old "verify_account" field's value of the WhatsappChannel entity.
// If the WhatsappChannel object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WhatsappChannelMutation) OldVerifyAccount(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldVerifyAccount is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldVerifyAccount requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldVerifyAccount: %w", err)
	}
	return oldValue.VerifyAccount, nil
}

// ResetVerifyAccount resets all changes to the "verify_account" field.
func (m *WhatsappChannelMutation) ResetVerifyAccount() {
	m.verify_account = nil
}

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

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

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

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

// Type returns the node type of this mutation (WhatsappChannel).
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, whatsappchannel.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, whatsappchannel.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, whatsappchannel.FieldStatus)
	}
	if m.deleted_at != nil {
		fields = append(fields, whatsappchannel.FieldDeletedAt)
	}
	if m.ak != nil {
		fields = append(fields, whatsappchannel.FieldAk)
	}
	if m.sk != nil {
		fields = append(fields, whatsappchannel.FieldSk)
	}
	if m.wa_id != nil {
		fields = append(fields, whatsappchannel.FieldWaID)
	}
	if m.wa_name != nil {
		fields = append(fields, whatsappchannel.FieldWaName)
	}
	if m.waba_id != nil {
		fields = append(fields, whatsappchannel.FieldWabaID)
	}
	if m.business_id != nil {
		fields = append(fields, whatsappchannel.FieldBusinessID)
	}
	if m.organization_id != nil {
		fields = append(fields, whatsappchannel.FieldOrganizationID)
	}
	if m.verify_account != nil {
		fields = append(fields, whatsappchannel.FieldVerifyAccount)
	}
	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 *WhatsappChannelMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case whatsappchannel.FieldCreatedAt:
		return m.CreatedAt()
	case whatsappchannel.FieldUpdatedAt:
		return m.UpdatedAt()
	case whatsappchannel.FieldStatus:
		return m.Status()
	case whatsappchannel.FieldDeletedAt:
		return m.DeletedAt()
	case whatsappchannel.FieldAk:
		return m.Ak()
	case whatsappchannel.FieldSk:
		return m.Sk()
	case whatsappchannel.FieldWaID:
		return m.WaID()
	case whatsappchannel.FieldWaName:
		return m.WaName()
	case whatsappchannel.FieldWabaID:
		return m.WabaID()
	case whatsappchannel.FieldBusinessID:
		return m.BusinessID()
	case whatsappchannel.FieldOrganizationID:
		return m.OrganizationID()
	case whatsappchannel.FieldVerifyAccount:
		return m.VerifyAccount()
	}
	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 *WhatsappChannelMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case whatsappchannel.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case whatsappchannel.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case whatsappchannel.FieldStatus:
		return m.OldStatus(ctx)
	case whatsappchannel.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case whatsappchannel.FieldAk:
		return m.OldAk(ctx)
	case whatsappchannel.FieldSk:
		return m.OldSk(ctx)
	case whatsappchannel.FieldWaID:
		return m.OldWaID(ctx)
	case whatsappchannel.FieldWaName:
		return m.OldWaName(ctx)
	case whatsappchannel.FieldWabaID:
		return m.OldWabaID(ctx)
	case whatsappchannel.FieldBusinessID:
		return m.OldBusinessID(ctx)
	case whatsappchannel.FieldOrganizationID:
		return m.OldOrganizationID(ctx)
	case whatsappchannel.FieldVerifyAccount:
		return m.OldVerifyAccount(ctx)
	}
	return nil, fmt.Errorf("unknown WhatsappChannel 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 *WhatsappChannelMutation) SetField(name string, value ent.Value) error {
	switch name {
	case whatsappchannel.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 whatsappchannel.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 whatsappchannel.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case whatsappchannel.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 whatsappchannel.FieldAk:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAk(v)
		return nil
	case whatsappchannel.FieldSk:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSk(v)
		return nil
	case whatsappchannel.FieldWaID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWaID(v)
		return nil
	case whatsappchannel.FieldWaName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWaName(v)
		return nil
	case whatsappchannel.FieldWabaID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWabaID(v)
		return nil
	case whatsappchannel.FieldBusinessID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBusinessID(v)
		return nil
	case whatsappchannel.FieldOrganizationID:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOrganizationID(v)
		return nil
	case whatsappchannel.FieldVerifyAccount:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetVerifyAccount(v)
		return nil
	}
	return fmt.Errorf("unknown WhatsappChannel field %s", name)
}

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

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WhatsappChannelMutation) 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 *WhatsappChannelMutation) ClearField(name string) error {
	switch name {
	case whatsappchannel.FieldStatus:
		m.ClearStatus()
		return nil
	case whatsappchannel.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	case whatsappchannel.FieldAk:
		m.ClearAk()
		return nil
	case whatsappchannel.FieldWaID:
		m.ClearWaID()
		return nil
	case whatsappchannel.FieldWaName:
		m.ClearWaName()
		return nil
	case whatsappchannel.FieldOrganizationID:
		m.ClearOrganizationID()
		return nil
	}
	return fmt.Errorf("unknown WhatsappChannel 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 *WhatsappChannelMutation) ResetField(name string) error {
	switch name {
	case whatsappchannel.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case whatsappchannel.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case whatsappchannel.FieldStatus:
		m.ResetStatus()
		return nil
	case whatsappchannel.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case whatsappchannel.FieldAk:
		m.ResetAk()
		return nil
	case whatsappchannel.FieldSk:
		m.ResetSk()
		return nil
	case whatsappchannel.FieldWaID:
		m.ResetWaID()
		return nil
	case whatsappchannel.FieldWaName:
		m.ResetWaName()
		return nil
	case whatsappchannel.FieldWabaID:
		m.ResetWabaID()
		return nil
	case whatsappchannel.FieldBusinessID:
		m.ResetBusinessID()
		return nil
	case whatsappchannel.FieldOrganizationID:
		m.ResetOrganizationID()
		return nil
	case whatsappchannel.FieldVerifyAccount:
		m.ResetVerifyAccount()
		return nil
	}
	return fmt.Errorf("unknown WhatsappChannel field %s", name)
}

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

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

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

// WpChatroomMutation represents an operation that mutates the WpChatroom nodes in the graph.
type WpChatroomMutation struct {
	config
	op                Op
	typ               string
	id                *uint64
	created_at        *time.Time
	updated_at        *time.Time
	status            *uint8
	addstatus         *int8
	wx_wxid           *string
	chatroom_id       *string
	nickname          *string
	owner             *string
	avatar            *string
	member_list       *[]string
	appendmember_list []string
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*WpChatroom, error)
	predicates        []predicate.WpChatroom
}

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

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

// newWpChatroomMutation creates new mutation for the WpChatroom entity.
func newWpChatroomMutation(c config, op Op, opts ...wpchatroomOption) *WpChatroomMutation {
	m := &WpChatroomMutation{
		config:        c,
		op:            op,
		typ:           TypeWpChatroom,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) 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 *WpChatroomMutation) 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 *WpChatroomMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[wpchatroom.FieldStatus] = struct{}{}
}

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

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

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

// WxWxid returns the value of the "wx_wxid" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ResetWxWxid() {
	m.wx_wxid = nil
}

// SetChatroomID sets the "chatroom_id" field.
func (m *WpChatroomMutation) SetChatroomID(s string) {
	m.chatroom_id = &s
}

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

// OldChatroomID returns the old "chatroom_id" field's value of the WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) OldChatroomID(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldChatroomID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldChatroomID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldChatroomID: %w", err)
	}
	return oldValue.ChatroomID, nil
}

// ResetChatroomID resets all changes to the "chatroom_id" field.
func (m *WpChatroomMutation) ResetChatroomID() {
	m.chatroom_id = nil
}

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

// Nickname returns the value of the "nickname" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ResetNickname() {
	m.nickname = nil
}

// SetOwner sets the "owner" field.
func (m *WpChatroomMutation) SetOwner(s string) {
	m.owner = &s
}

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

// OldOwner returns the old "owner" field's value of the WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) OldOwner(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOwner is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOwner requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOwner: %w", err)
	}
	return oldValue.Owner, nil
}

// ResetOwner resets all changes to the "owner" field.
func (m *WpChatroomMutation) ResetOwner() {
	m.owner = nil
}

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

// Avatar returns the value of the "avatar" field in the mutation.
func (m *WpChatroomMutation) 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 WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ResetAvatar() {
	m.avatar = nil
}

// SetMemberList sets the "member_list" field.
func (m *WpChatroomMutation) SetMemberList(s []string) {
	m.member_list = &s
	m.appendmember_list = nil
}

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

// OldMemberList returns the old "member_list" field's value of the WpChatroom entity.
// If the WpChatroom object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMutation) OldMemberList(ctx context.Context) (v []string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldMemberList is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldMemberList requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldMemberList: %w", err)
	}
	return oldValue.MemberList, nil
}

// AppendMemberList adds s to the "member_list" field.
func (m *WpChatroomMutation) AppendMemberList(s []string) {
	m.appendmember_list = append(m.appendmember_list, s...)
}

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

// ResetMemberList resets all changes to the "member_list" field.
func (m *WpChatroomMutation) ResetMemberList() {
	m.member_list = nil
	m.appendmember_list = nil
}

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

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

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

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

// Type returns the node type of this mutation (WpChatroom).
func (m *WpChatroomMutation) 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 *WpChatroomMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, wpchatroom.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wpchatroom.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, wpchatroom.FieldStatus)
	}
	if m.wx_wxid != nil {
		fields = append(fields, wpchatroom.FieldWxWxid)
	}
	if m.chatroom_id != nil {
		fields = append(fields, wpchatroom.FieldChatroomID)
	}
	if m.nickname != nil {
		fields = append(fields, wpchatroom.FieldNickname)
	}
	if m.owner != nil {
		fields = append(fields, wpchatroom.FieldOwner)
	}
	if m.avatar != nil {
		fields = append(fields, wpchatroom.FieldAvatar)
	}
	if m.member_list != nil {
		fields = append(fields, wpchatroom.FieldMemberList)
	}
	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 *WpChatroomMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wpchatroom.FieldCreatedAt:
		return m.CreatedAt()
	case wpchatroom.FieldUpdatedAt:
		return m.UpdatedAt()
	case wpchatroom.FieldStatus:
		return m.Status()
	case wpchatroom.FieldWxWxid:
		return m.WxWxid()
	case wpchatroom.FieldChatroomID:
		return m.ChatroomID()
	case wpchatroom.FieldNickname:
		return m.Nickname()
	case wpchatroom.FieldOwner:
		return m.Owner()
	case wpchatroom.FieldAvatar:
		return m.Avatar()
	case wpchatroom.FieldMemberList:
		return m.MemberList()
	}
	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 *WpChatroomMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wpchatroom.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wpchatroom.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wpchatroom.FieldStatus:
		return m.OldStatus(ctx)
	case wpchatroom.FieldWxWxid:
		return m.OldWxWxid(ctx)
	case wpchatroom.FieldChatroomID:
		return m.OldChatroomID(ctx)
	case wpchatroom.FieldNickname:
		return m.OldNickname(ctx)
	case wpchatroom.FieldOwner:
		return m.OldOwner(ctx)
	case wpchatroom.FieldAvatar:
		return m.OldAvatar(ctx)
	case wpchatroom.FieldMemberList:
		return m.OldMemberList(ctx)
	}
	return nil, fmt.Errorf("unknown WpChatroom 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 *WpChatroomMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wpchatroom.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 wpchatroom.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 wpchatroom.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case wpchatroom.FieldWxWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxWxid(v)
		return nil
	case wpchatroom.FieldChatroomID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChatroomID(v)
		return nil
	case wpchatroom.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case wpchatroom.FieldOwner:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOwner(v)
		return nil
	case wpchatroom.FieldAvatar:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatar(v)
		return nil
	case wpchatroom.FieldMemberList:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMemberList(v)
		return nil
	}
	return fmt.Errorf("unknown WpChatroom field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WpChatroomMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, wpchatroom.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 *WpChatroomMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case wpchatroom.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 *WpChatroomMutation) AddField(name string, value ent.Value) error {
	switch name {
	case wpchatroom.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 WpChatroom numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WpChatroomMutation) 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 *WpChatroomMutation) ClearField(name string) error {
	switch name {
	case wpchatroom.FieldStatus:
		m.ClearStatus()
		return nil
	}
	return fmt.Errorf("unknown WpChatroom 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 *WpChatroomMutation) ResetField(name string) error {
	switch name {
	case wpchatroom.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wpchatroom.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wpchatroom.FieldStatus:
		m.ResetStatus()
		return nil
	case wpchatroom.FieldWxWxid:
		m.ResetWxWxid()
		return nil
	case wpchatroom.FieldChatroomID:
		m.ResetChatroomID()
		return nil
	case wpchatroom.FieldNickname:
		m.ResetNickname()
		return nil
	case wpchatroom.FieldOwner:
		m.ResetOwner()
		return nil
	case wpchatroom.FieldAvatar:
		m.ResetAvatar()
		return nil
	case wpchatroom.FieldMemberList:
		m.ResetMemberList()
		return nil
	}
	return fmt.Errorf("unknown WpChatroom field %s", name)
}

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

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

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

// WpChatroomMemberMutation represents an operation that mutates the WpChatroomMember nodes in the graph.
type WpChatroomMemberMutation struct {
	config
	op            Op
	typ           string
	id            *uint64
	created_at    *time.Time
	updated_at    *time.Time
	status        *uint8
	addstatus     *int8
	wx_wxid       *string
	wxid          *string
	nickname      *string
	avatar        *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*WpChatroomMember, error)
	predicates    []predicate.WpChatroomMember
}

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

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

// newWpChatroomMemberMutation creates new mutation for the WpChatroomMember entity.
func newWpChatroomMemberMutation(c config, op Op, opts ...wpchatroommemberOption) *WpChatroomMemberMutation {
	m := &WpChatroomMemberMutation{
		config:        c,
		op:            op,
		typ:           TypeWpChatroomMember,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetCreatedAt() {
	m.created_at = nil
}

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

// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

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

// Status returns the value of the "status" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ClearStatus() {
	m.status = nil
	m.addstatus = nil
	m.clearedFields[wpchatroommember.FieldStatus] = struct{}{}
}

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

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

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

// WxWxid returns the value of the "wx_wxid" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetWxWxid() {
	m.wx_wxid = nil
}

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

// Wxid returns the value of the "wxid" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetWxid() {
	m.wxid = nil
}

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

// Nickname returns the value of the "nickname" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetNickname() {
	m.nickname = nil
}

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

// Avatar returns the value of the "avatar" field in the mutation.
func (m *WpChatroomMemberMutation) 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 WpChatroomMember entity.
// If the WpChatroomMember object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ResetAvatar() {
	m.avatar = nil
}

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

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

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

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

// Type returns the node type of this mutation (WpChatroomMember).
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, wpchatroommember.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, wpchatroommember.FieldUpdatedAt)
	}
	if m.status != nil {
		fields = append(fields, wpchatroommember.FieldStatus)
	}
	if m.wx_wxid != nil {
		fields = append(fields, wpchatroommember.FieldWxWxid)
	}
	if m.wxid != nil {
		fields = append(fields, wpchatroommember.FieldWxid)
	}
	if m.nickname != nil {
		fields = append(fields, wpchatroommember.FieldNickname)
	}
	if m.avatar != nil {
		fields = append(fields, wpchatroommember.FieldAvatar)
	}
	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 *WpChatroomMemberMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case wpchatroommember.FieldCreatedAt:
		return m.CreatedAt()
	case wpchatroommember.FieldUpdatedAt:
		return m.UpdatedAt()
	case wpchatroommember.FieldStatus:
		return m.Status()
	case wpchatroommember.FieldWxWxid:
		return m.WxWxid()
	case wpchatroommember.FieldWxid:
		return m.Wxid()
	case wpchatroommember.FieldNickname:
		return m.Nickname()
	case wpchatroommember.FieldAvatar:
		return m.Avatar()
	}
	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 *WpChatroomMemberMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case wpchatroommember.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case wpchatroommember.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case wpchatroommember.FieldStatus:
		return m.OldStatus(ctx)
	case wpchatroommember.FieldWxWxid:
		return m.OldWxWxid(ctx)
	case wpchatroommember.FieldWxid:
		return m.OldWxid(ctx)
	case wpchatroommember.FieldNickname:
		return m.OldNickname(ctx)
	case wpchatroommember.FieldAvatar:
		return m.OldAvatar(ctx)
	}
	return nil, fmt.Errorf("unknown WpChatroomMember 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 *WpChatroomMemberMutation) SetField(name string, value ent.Value) error {
	switch name {
	case wpchatroommember.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 wpchatroommember.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 wpchatroommember.FieldStatus:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case wpchatroommember.FieldWxWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxWxid(v)
		return nil
	case wpchatroommember.FieldWxid:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWxid(v)
		return nil
	case wpchatroommember.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case wpchatroommember.FieldAvatar:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAvatar(v)
		return nil
	}
	return fmt.Errorf("unknown WpChatroomMember field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WpChatroomMemberMutation) AddedFields() []string {
	var fields []string
	if m.addstatus != nil {
		fields = append(fields, wpchatroommember.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 *WpChatroomMemberMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case wpchatroommember.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 *WpChatroomMemberMutation) AddField(name string, value ent.Value) error {
	switch name {
	case wpchatroommember.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 WpChatroomMember numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WpChatroomMemberMutation) 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 *WpChatroomMemberMutation) ClearField(name string) error {
	switch name {
	case wpchatroommember.FieldStatus:
		m.ClearStatus()
		return nil
	}
	return fmt.Errorf("unknown WpChatroomMember 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 *WpChatroomMemberMutation) ResetField(name string) error {
	switch name {
	case wpchatroommember.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case wpchatroommember.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case wpchatroommember.FieldStatus:
		m.ResetStatus()
		return nil
	case wpchatroommember.FieldWxWxid:
		m.ResetWxWxid()
		return nil
	case wpchatroommember.FieldWxid:
		m.ResetWxid()
		return nil
	case wpchatroommember.FieldNickname:
		m.ResetNickname()
		return nil
	case wpchatroommember.FieldAvatar:
		m.ResetAvatar()
		return nil
	}
	return fmt.Errorf("unknown WpChatroomMember field %s", name)
}

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

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

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

// SetCtype sets the "ctype" field.
func (m *WxMutation) SetCtype(u uint64) {
	m.ctype = &u
	m.addctype = nil
}

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

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

// AddCtype adds u to the "ctype" field.
func (m *WxMutation) AddCtype(u int64) {
	if m.addctype != nil {
		*m.addctype += u
	} else {
		m.addctype = &u
	}
}

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

// ClearCtype clears the value of the "ctype" field.
func (m *WxMutation) ClearCtype() {
	m.ctype = nil
	m.addctype = nil
	m.clearedFields[wx.FieldCtype] = struct{}{}
}

// CtypeCleared returns if the "ctype" field was cleared in this mutation.
func (m *WxMutation) CtypeCleared() bool {
	_, ok := m.clearedFields[wx.FieldCtype]
	return ok
}

// ResetCtype resets all changes to the "ctype" field.
func (m *WxMutation) ResetCtype() {
	m.ctype = nil
	m.addctype = nil
	delete(m.clearedFields, wx.FieldCtype)
}

// 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, 22)
	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)
	}
	if m.ctype != nil {
		fields = append(fields, wx.FieldCtype)
	}
	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()
	case wx.FieldCtype:
		return m.Ctype()
	}
	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)
	case wx.FieldCtype:
		return m.OldCtype(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
	case wx.FieldCtype:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCtype(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)
	}
	if m.addctype != nil {
		fields = append(fields, wx.FieldCtype)
	}
	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()
	case wx.FieldCtype:
		return m.AddedCtype()
	}
	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
	case wx.FieldCtype:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCtype(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)
	}
	if m.FieldCleared(wx.FieldCtype) {
		fields = append(fields, wx.FieldCtype)
	}
	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
	case wx.FieldCtype:
		m.ClearCtype()
		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
	case wx.FieldCtype:
		m.ResetCtype()
		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)
}