github.com/NpoolPlatform/chain-middleware@v0.0.0-20240228100535-eb1bcf896eb9/pkg/db/ent/mutation.go

// Code generated by ent, DO NOT EDIT.

package ent

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

	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/appcoin"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/chainbase"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinbase"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coindescription"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinextra"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinfiat"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinfiatcurrency"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinfiatcurrencyhistory"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinusedfor"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/currency"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/currencyfeed"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/currencyhistory"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/exchangerate"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/fiat"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/fiatcurrency"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/fiatcurrencyfeed"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/fiatcurrencyhistory"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/predicate"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/setting"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/tran"
	"github.com/google/uuid"
	"github.com/shopspring/decimal"

	"entgo.io/ent"
)

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

	// Node types.
	TypeAppCoin                 = "AppCoin"
	TypeChainBase               = "ChainBase"
	TypeCoinBase                = "CoinBase"
	TypeCoinDescription         = "CoinDescription"
	TypeCoinExtra               = "CoinExtra"
	TypeCoinFiat                = "CoinFiat"
	TypeCoinFiatCurrency        = "CoinFiatCurrency"
	TypeCoinFiatCurrencyHistory = "CoinFiatCurrencyHistory"
	TypeCoinUsedFor             = "CoinUsedFor"
	TypeCurrency                = "Currency"
	TypeCurrencyFeed            = "CurrencyFeed"
	TypeCurrencyHistory         = "CurrencyHistory"
	TypeExchangeRate            = "ExchangeRate"
	TypeFiat                    = "Fiat"
	TypeFiatCurrency            = "FiatCurrency"
	TypeFiatCurrencyFeed        = "FiatCurrencyFeed"
	TypeFiatCurrencyHistory     = "FiatCurrencyHistory"
	TypeSetting                 = "Setting"
	TypeTran                    = "Tran"
)

// AppCoinMutation represents an operation that mutates the AppCoin nodes in the graph.
type AppCoinMutation struct {
	config
	op                          Op
	typ                         string
	id                          *uint32
	created_at                  *uint32
	addcreated_at               *int32
	updated_at                  *uint32
	addupdated_at               *int32
	deleted_at                  *uint32
	adddeleted_at               *int32
	ent_id                      *uuid.UUID
	app_id                      *uuid.UUID
	coin_type_id                *uuid.UUID
	name                        *string
	display_names               *[]string
	logo                        *string
	for_pay                     *bool
	withdraw_auto_review_amount *decimal.Decimal
	product_page                *string
	disabled                    *bool
	daily_reward_amount         *decimal.Decimal
	display                     *bool
	display_index               *uint32
	adddisplay_index            *int32
	max_amount_per_withdraw     *decimal.Decimal
	clearedFields               map[string]struct{}
	done                        bool
	oldValue                    func(context.Context) (*AppCoin, error)
	predicates                  []predicate.AppCoin
}

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

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

// newAppCoinMutation creates new mutation for the AppCoin entity.
func newAppCoinMutation(c config, op Op, opts ...appcoinOption) *AppCoinMutation {
	m := &AppCoinMutation{
		config:        c,
		op:            op,
		typ:           TypeAppCoin,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withAppCoin sets the old AppCoin of the mutation.
func withAppCoin(node *AppCoin) appcoinOption {
	return func(m *AppCoinMutation) {
		m.oldValue = func(context.Context) (*AppCoin, 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 AppCoinMutation) 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 AppCoinMutation) 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 AppCoin entities.
func (m *AppCoinMutation) SetID(id uint32) {
	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 *AppCoinMutation) ID() (id uint32, 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 *AppCoinMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().AppCoin.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 *AppCoinMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *AppCoinMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *AppCoinMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *AppCoinMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *AppCoinMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *AppCoinMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *AppCoinMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *AppCoinMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *AppCoinMutation) ResetEntID() {
	m.ent_id = nil
}

// SetAppID sets the "app_id" field.
func (m *AppCoinMutation) SetAppID(u uuid.UUID) {
	m.app_id = &u
}

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

// OldAppID returns the old "app_id" field's value of the AppCoin entity.
// If the AppCoin object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *AppCoinMutation) OldAppID(ctx context.Context) (v uuid.UUID, 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 *AppCoinMutation) ClearAppID() {
	m.app_id = nil
	m.clearedFields[appcoin.FieldAppID] = struct{}{}
}

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

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

// SetCoinTypeID sets the "coin_type_id" field.
func (m *AppCoinMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *AppCoinMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[appcoin.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *AppCoinMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *AppCoinMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, appcoin.FieldCoinTypeID)
}

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

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

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

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

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

// SetDisplayNames sets the "display_names" field.
func (m *AppCoinMutation) SetDisplayNames(s []string) {
	m.display_names = &s
}

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

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

// ClearDisplayNames clears the value of the "display_names" field.
func (m *AppCoinMutation) ClearDisplayNames() {
	m.display_names = nil
	m.clearedFields[appcoin.FieldDisplayNames] = struct{}{}
}

// DisplayNamesCleared returns if the "display_names" field was cleared in this mutation.
func (m *AppCoinMutation) DisplayNamesCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldDisplayNames]
	return ok
}

// ResetDisplayNames resets all changes to the "display_names" field.
func (m *AppCoinMutation) ResetDisplayNames() {
	m.display_names = nil
	delete(m.clearedFields, appcoin.FieldDisplayNames)
}

// SetLogo sets the "logo" field.
func (m *AppCoinMutation) SetLogo(s string) {
	m.logo = &s
}

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

// ClearLogo clears the value of the "logo" field.
func (m *AppCoinMutation) ClearLogo() {
	m.logo = nil
	m.clearedFields[appcoin.FieldLogo] = struct{}{}
}

// LogoCleared returns if the "logo" field was cleared in this mutation.
func (m *AppCoinMutation) LogoCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldLogo]
	return ok
}

// ResetLogo resets all changes to the "logo" field.
func (m *AppCoinMutation) ResetLogo() {
	m.logo = nil
	delete(m.clearedFields, appcoin.FieldLogo)
}

// SetForPay sets the "for_pay" field.
func (m *AppCoinMutation) SetForPay(b bool) {
	m.for_pay = &b
}

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

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

// ClearForPay clears the value of the "for_pay" field.
func (m *AppCoinMutation) ClearForPay() {
	m.for_pay = nil
	m.clearedFields[appcoin.FieldForPay] = struct{}{}
}

// ForPayCleared returns if the "for_pay" field was cleared in this mutation.
func (m *AppCoinMutation) ForPayCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldForPay]
	return ok
}

// ResetForPay resets all changes to the "for_pay" field.
func (m *AppCoinMutation) ResetForPay() {
	m.for_pay = nil
	delete(m.clearedFields, appcoin.FieldForPay)
}

// SetWithdrawAutoReviewAmount sets the "withdraw_auto_review_amount" field.
func (m *AppCoinMutation) SetWithdrawAutoReviewAmount(d decimal.Decimal) {
	m.withdraw_auto_review_amount = &d
}

// WithdrawAutoReviewAmount returns the value of the "withdraw_auto_review_amount" field in the mutation.
func (m *AppCoinMutation) WithdrawAutoReviewAmount() (r decimal.Decimal, exists bool) {
	v := m.withdraw_auto_review_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearWithdrawAutoReviewAmount clears the value of the "withdraw_auto_review_amount" field.
func (m *AppCoinMutation) ClearWithdrawAutoReviewAmount() {
	m.withdraw_auto_review_amount = nil
	m.clearedFields[appcoin.FieldWithdrawAutoReviewAmount] = struct{}{}
}

// WithdrawAutoReviewAmountCleared returns if the "withdraw_auto_review_amount" field was cleared in this mutation.
func (m *AppCoinMutation) WithdrawAutoReviewAmountCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldWithdrawAutoReviewAmount]
	return ok
}

// ResetWithdrawAutoReviewAmount resets all changes to the "withdraw_auto_review_amount" field.
func (m *AppCoinMutation) ResetWithdrawAutoReviewAmount() {
	m.withdraw_auto_review_amount = nil
	delete(m.clearedFields, appcoin.FieldWithdrawAutoReviewAmount)
}

// SetProductPage sets the "product_page" field.
func (m *AppCoinMutation) SetProductPage(s string) {
	m.product_page = &s
}

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

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

// ClearProductPage clears the value of the "product_page" field.
func (m *AppCoinMutation) ClearProductPage() {
	m.product_page = nil
	m.clearedFields[appcoin.FieldProductPage] = struct{}{}
}

// ProductPageCleared returns if the "product_page" field was cleared in this mutation.
func (m *AppCoinMutation) ProductPageCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldProductPage]
	return ok
}

// ResetProductPage resets all changes to the "product_page" field.
func (m *AppCoinMutation) ResetProductPage() {
	m.product_page = nil
	delete(m.clearedFields, appcoin.FieldProductPage)
}

// SetDisabled sets the "disabled" field.
func (m *AppCoinMutation) SetDisabled(b bool) {
	m.disabled = &b
}

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

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

// ClearDisabled clears the value of the "disabled" field.
func (m *AppCoinMutation) ClearDisabled() {
	m.disabled = nil
	m.clearedFields[appcoin.FieldDisabled] = struct{}{}
}

// DisabledCleared returns if the "disabled" field was cleared in this mutation.
func (m *AppCoinMutation) DisabledCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldDisabled]
	return ok
}

// ResetDisabled resets all changes to the "disabled" field.
func (m *AppCoinMutation) ResetDisabled() {
	m.disabled = nil
	delete(m.clearedFields, appcoin.FieldDisabled)
}

// SetDailyRewardAmount sets the "daily_reward_amount" field.
func (m *AppCoinMutation) SetDailyRewardAmount(d decimal.Decimal) {
	m.daily_reward_amount = &d
}

// DailyRewardAmount returns the value of the "daily_reward_amount" field in the mutation.
func (m *AppCoinMutation) DailyRewardAmount() (r decimal.Decimal, exists bool) {
	v := m.daily_reward_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearDailyRewardAmount clears the value of the "daily_reward_amount" field.
func (m *AppCoinMutation) ClearDailyRewardAmount() {
	m.daily_reward_amount = nil
	m.clearedFields[appcoin.FieldDailyRewardAmount] = struct{}{}
}

// DailyRewardAmountCleared returns if the "daily_reward_amount" field was cleared in this mutation.
func (m *AppCoinMutation) DailyRewardAmountCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldDailyRewardAmount]
	return ok
}

// ResetDailyRewardAmount resets all changes to the "daily_reward_amount" field.
func (m *AppCoinMutation) ResetDailyRewardAmount() {
	m.daily_reward_amount = nil
	delete(m.clearedFields, appcoin.FieldDailyRewardAmount)
}

// SetDisplay sets the "display" field.
func (m *AppCoinMutation) SetDisplay(b bool) {
	m.display = &b
}

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

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

// ClearDisplay clears the value of the "display" field.
func (m *AppCoinMutation) ClearDisplay() {
	m.display = nil
	m.clearedFields[appcoin.FieldDisplay] = struct{}{}
}

// DisplayCleared returns if the "display" field was cleared in this mutation.
func (m *AppCoinMutation) DisplayCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldDisplay]
	return ok
}

// ResetDisplay resets all changes to the "display" field.
func (m *AppCoinMutation) ResetDisplay() {
	m.display = nil
	delete(m.clearedFields, appcoin.FieldDisplay)
}

// SetDisplayIndex sets the "display_index" field.
func (m *AppCoinMutation) SetDisplayIndex(u uint32) {
	m.display_index = &u
	m.adddisplay_index = nil
}

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

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

// AddDisplayIndex adds u to the "display_index" field.
func (m *AppCoinMutation) AddDisplayIndex(u int32) {
	if m.adddisplay_index != nil {
		*m.adddisplay_index += u
	} else {
		m.adddisplay_index = &u
	}
}

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

// ClearDisplayIndex clears the value of the "display_index" field.
func (m *AppCoinMutation) ClearDisplayIndex() {
	m.display_index = nil
	m.adddisplay_index = nil
	m.clearedFields[appcoin.FieldDisplayIndex] = struct{}{}
}

// DisplayIndexCleared returns if the "display_index" field was cleared in this mutation.
func (m *AppCoinMutation) DisplayIndexCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldDisplayIndex]
	return ok
}

// ResetDisplayIndex resets all changes to the "display_index" field.
func (m *AppCoinMutation) ResetDisplayIndex() {
	m.display_index = nil
	m.adddisplay_index = nil
	delete(m.clearedFields, appcoin.FieldDisplayIndex)
}

// SetMaxAmountPerWithdraw sets the "max_amount_per_withdraw" field.
func (m *AppCoinMutation) SetMaxAmountPerWithdraw(d decimal.Decimal) {
	m.max_amount_per_withdraw = &d
}

// MaxAmountPerWithdraw returns the value of the "max_amount_per_withdraw" field in the mutation.
func (m *AppCoinMutation) MaxAmountPerWithdraw() (r decimal.Decimal, exists bool) {
	v := m.max_amount_per_withdraw
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMaxAmountPerWithdraw clears the value of the "max_amount_per_withdraw" field.
func (m *AppCoinMutation) ClearMaxAmountPerWithdraw() {
	m.max_amount_per_withdraw = nil
	m.clearedFields[appcoin.FieldMaxAmountPerWithdraw] = struct{}{}
}

// MaxAmountPerWithdrawCleared returns if the "max_amount_per_withdraw" field was cleared in this mutation.
func (m *AppCoinMutation) MaxAmountPerWithdrawCleared() bool {
	_, ok := m.clearedFields[appcoin.FieldMaxAmountPerWithdraw]
	return ok
}

// ResetMaxAmountPerWithdraw resets all changes to the "max_amount_per_withdraw" field.
func (m *AppCoinMutation) ResetMaxAmountPerWithdraw() {
	m.max_amount_per_withdraw = nil
	delete(m.clearedFields, appcoin.FieldMaxAmountPerWithdraw)
}

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

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

// Type returns the node type of this mutation (AppCoin).
func (m *AppCoinMutation) 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 *AppCoinMutation) Fields() []string {
	fields := make([]string, 0, 17)
	if m.created_at != nil {
		fields = append(fields, appcoin.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, appcoin.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, appcoin.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, appcoin.FieldEntID)
	}
	if m.app_id != nil {
		fields = append(fields, appcoin.FieldAppID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, appcoin.FieldCoinTypeID)
	}
	if m.name != nil {
		fields = append(fields, appcoin.FieldName)
	}
	if m.display_names != nil {
		fields = append(fields, appcoin.FieldDisplayNames)
	}
	if m.logo != nil {
		fields = append(fields, appcoin.FieldLogo)
	}
	if m.for_pay != nil {
		fields = append(fields, appcoin.FieldForPay)
	}
	if m.withdraw_auto_review_amount != nil {
		fields = append(fields, appcoin.FieldWithdrawAutoReviewAmount)
	}
	if m.product_page != nil {
		fields = append(fields, appcoin.FieldProductPage)
	}
	if m.disabled != nil {
		fields = append(fields, appcoin.FieldDisabled)
	}
	if m.daily_reward_amount != nil {
		fields = append(fields, appcoin.FieldDailyRewardAmount)
	}
	if m.display != nil {
		fields = append(fields, appcoin.FieldDisplay)
	}
	if m.display_index != nil {
		fields = append(fields, appcoin.FieldDisplayIndex)
	}
	if m.max_amount_per_withdraw != nil {
		fields = append(fields, appcoin.FieldMaxAmountPerWithdraw)
	}
	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 *AppCoinMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case appcoin.FieldCreatedAt:
		return m.CreatedAt()
	case appcoin.FieldUpdatedAt:
		return m.UpdatedAt()
	case appcoin.FieldDeletedAt:
		return m.DeletedAt()
	case appcoin.FieldEntID:
		return m.EntID()
	case appcoin.FieldAppID:
		return m.AppID()
	case appcoin.FieldCoinTypeID:
		return m.CoinTypeID()
	case appcoin.FieldName:
		return m.Name()
	case appcoin.FieldDisplayNames:
		return m.DisplayNames()
	case appcoin.FieldLogo:
		return m.Logo()
	case appcoin.FieldForPay:
		return m.ForPay()
	case appcoin.FieldWithdrawAutoReviewAmount:
		return m.WithdrawAutoReviewAmount()
	case appcoin.FieldProductPage:
		return m.ProductPage()
	case appcoin.FieldDisabled:
		return m.Disabled()
	case appcoin.FieldDailyRewardAmount:
		return m.DailyRewardAmount()
	case appcoin.FieldDisplay:
		return m.Display()
	case appcoin.FieldDisplayIndex:
		return m.DisplayIndex()
	case appcoin.FieldMaxAmountPerWithdraw:
		return m.MaxAmountPerWithdraw()
	}
	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 *AppCoinMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case appcoin.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case appcoin.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case appcoin.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case appcoin.FieldEntID:
		return m.OldEntID(ctx)
	case appcoin.FieldAppID:
		return m.OldAppID(ctx)
	case appcoin.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case appcoin.FieldName:
		return m.OldName(ctx)
	case appcoin.FieldDisplayNames:
		return m.OldDisplayNames(ctx)
	case appcoin.FieldLogo:
		return m.OldLogo(ctx)
	case appcoin.FieldForPay:
		return m.OldForPay(ctx)
	case appcoin.FieldWithdrawAutoReviewAmount:
		return m.OldWithdrawAutoReviewAmount(ctx)
	case appcoin.FieldProductPage:
		return m.OldProductPage(ctx)
	case appcoin.FieldDisabled:
		return m.OldDisabled(ctx)
	case appcoin.FieldDailyRewardAmount:
		return m.OldDailyRewardAmount(ctx)
	case appcoin.FieldDisplay:
		return m.OldDisplay(ctx)
	case appcoin.FieldDisplayIndex:
		return m.OldDisplayIndex(ctx)
	case appcoin.FieldMaxAmountPerWithdraw:
		return m.OldMaxAmountPerWithdraw(ctx)
	}
	return nil, fmt.Errorf("unknown AppCoin 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 *AppCoinMutation) SetField(name string, value ent.Value) error {
	switch name {
	case appcoin.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case appcoin.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case appcoin.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case appcoin.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case appcoin.FieldAppID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAppID(v)
		return nil
	case appcoin.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case appcoin.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case appcoin.FieldDisplayNames:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisplayNames(v)
		return nil
	case appcoin.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	case appcoin.FieldForPay:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetForPay(v)
		return nil
	case appcoin.FieldWithdrawAutoReviewAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWithdrawAutoReviewAmount(v)
		return nil
	case appcoin.FieldProductPage:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetProductPage(v)
		return nil
	case appcoin.FieldDisabled:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisabled(v)
		return nil
	case appcoin.FieldDailyRewardAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDailyRewardAmount(v)
		return nil
	case appcoin.FieldDisplay:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisplay(v)
		return nil
	case appcoin.FieldDisplayIndex:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisplayIndex(v)
		return nil
	case appcoin.FieldMaxAmountPerWithdraw:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMaxAmountPerWithdraw(v)
		return nil
	}
	return fmt.Errorf("unknown AppCoin field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *AppCoinMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, appcoin.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, appcoin.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, appcoin.FieldDeletedAt)
	}
	if m.adddisplay_index != nil {
		fields = append(fields, appcoin.FieldDisplayIndex)
	}
	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 *AppCoinMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case appcoin.FieldCreatedAt:
		return m.AddedCreatedAt()
	case appcoin.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case appcoin.FieldDeletedAt:
		return m.AddedDeletedAt()
	case appcoin.FieldDisplayIndex:
		return m.AddedDisplayIndex()
	}
	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 *AppCoinMutation) AddField(name string, value ent.Value) error {
	switch name {
	case appcoin.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case appcoin.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case appcoin.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	case appcoin.FieldDisplayIndex:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDisplayIndex(v)
		return nil
	}
	return fmt.Errorf("unknown AppCoin numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *AppCoinMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(appcoin.FieldAppID) {
		fields = append(fields, appcoin.FieldAppID)
	}
	if m.FieldCleared(appcoin.FieldCoinTypeID) {
		fields = append(fields, appcoin.FieldCoinTypeID)
	}
	if m.FieldCleared(appcoin.FieldName) {
		fields = append(fields, appcoin.FieldName)
	}
	if m.FieldCleared(appcoin.FieldDisplayNames) {
		fields = append(fields, appcoin.FieldDisplayNames)
	}
	if m.FieldCleared(appcoin.FieldLogo) {
		fields = append(fields, appcoin.FieldLogo)
	}
	if m.FieldCleared(appcoin.FieldForPay) {
		fields = append(fields, appcoin.FieldForPay)
	}
	if m.FieldCleared(appcoin.FieldWithdrawAutoReviewAmount) {
		fields = append(fields, appcoin.FieldWithdrawAutoReviewAmount)
	}
	if m.FieldCleared(appcoin.FieldProductPage) {
		fields = append(fields, appcoin.FieldProductPage)
	}
	if m.FieldCleared(appcoin.FieldDisabled) {
		fields = append(fields, appcoin.FieldDisabled)
	}
	if m.FieldCleared(appcoin.FieldDailyRewardAmount) {
		fields = append(fields, appcoin.FieldDailyRewardAmount)
	}
	if m.FieldCleared(appcoin.FieldDisplay) {
		fields = append(fields, appcoin.FieldDisplay)
	}
	if m.FieldCleared(appcoin.FieldDisplayIndex) {
		fields = append(fields, appcoin.FieldDisplayIndex)
	}
	if m.FieldCleared(appcoin.FieldMaxAmountPerWithdraw) {
		fields = append(fields, appcoin.FieldMaxAmountPerWithdraw)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *AppCoinMutation) 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 *AppCoinMutation) ClearField(name string) error {
	switch name {
	case appcoin.FieldAppID:
		m.ClearAppID()
		return nil
	case appcoin.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case appcoin.FieldName:
		m.ClearName()
		return nil
	case appcoin.FieldDisplayNames:
		m.ClearDisplayNames()
		return nil
	case appcoin.FieldLogo:
		m.ClearLogo()
		return nil
	case appcoin.FieldForPay:
		m.ClearForPay()
		return nil
	case appcoin.FieldWithdrawAutoReviewAmount:
		m.ClearWithdrawAutoReviewAmount()
		return nil
	case appcoin.FieldProductPage:
		m.ClearProductPage()
		return nil
	case appcoin.FieldDisabled:
		m.ClearDisabled()
		return nil
	case appcoin.FieldDailyRewardAmount:
		m.ClearDailyRewardAmount()
		return nil
	case appcoin.FieldDisplay:
		m.ClearDisplay()
		return nil
	case appcoin.FieldDisplayIndex:
		m.ClearDisplayIndex()
		return nil
	case appcoin.FieldMaxAmountPerWithdraw:
		m.ClearMaxAmountPerWithdraw()
		return nil
	}
	return fmt.Errorf("unknown AppCoin 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 *AppCoinMutation) ResetField(name string) error {
	switch name {
	case appcoin.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case appcoin.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case appcoin.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case appcoin.FieldEntID:
		m.ResetEntID()
		return nil
	case appcoin.FieldAppID:
		m.ResetAppID()
		return nil
	case appcoin.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case appcoin.FieldName:
		m.ResetName()
		return nil
	case appcoin.FieldDisplayNames:
		m.ResetDisplayNames()
		return nil
	case appcoin.FieldLogo:
		m.ResetLogo()
		return nil
	case appcoin.FieldForPay:
		m.ResetForPay()
		return nil
	case appcoin.FieldWithdrawAutoReviewAmount:
		m.ResetWithdrawAutoReviewAmount()
		return nil
	case appcoin.FieldProductPage:
		m.ResetProductPage()
		return nil
	case appcoin.FieldDisabled:
		m.ResetDisabled()
		return nil
	case appcoin.FieldDailyRewardAmount:
		m.ResetDailyRewardAmount()
		return nil
	case appcoin.FieldDisplay:
		m.ResetDisplay()
		return nil
	case appcoin.FieldDisplayIndex:
		m.ResetDisplayIndex()
		return nil
	case appcoin.FieldMaxAmountPerWithdraw:
		m.ResetMaxAmountPerWithdraw()
		return nil
	}
	return fmt.Errorf("unknown AppCoin field %s", name)
}

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

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

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

// ChainBaseMutation represents an operation that mutates the ChainBase nodes in the graph.
type ChainBaseMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	name          *string
	logo          *string
	native_unit   *string
	atomic_unit   *string
	unit_exp      *uint32
	addunit_exp   *int32
	env           *string
	chain_id      *string
	nickname      *string
	gas_type      *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*ChainBase, error)
	predicates    []predicate.ChainBase
}

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

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

// newChainBaseMutation creates new mutation for the ChainBase entity.
func newChainBaseMutation(c config, op Op, opts ...chainbaseOption) *ChainBaseMutation {
	m := &ChainBaseMutation{
		config:        c,
		op:            op,
		typ:           TypeChainBase,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withChainBase sets the old ChainBase of the mutation.
func withChainBase(node *ChainBase) chainbaseOption {
	return func(m *ChainBaseMutation) {
		m.oldValue = func(context.Context) (*ChainBase, 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 ChainBaseMutation) 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 ChainBaseMutation) 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 ChainBase entities.
func (m *ChainBaseMutation) SetID(id uint32) {
	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 *ChainBaseMutation) ID() (id uint32, 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 *ChainBaseMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().ChainBase.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 *ChainBaseMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *ChainBaseMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *ChainBaseMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *ChainBaseMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *ChainBaseMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *ChainBaseMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *ChainBaseMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *ChainBaseMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *ChainBaseMutation) ResetEntID() {
	m.ent_id = nil
}

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

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

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

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

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

// SetLogo sets the "logo" field.
func (m *ChainBaseMutation) SetLogo(s string) {
	m.logo = &s
}

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

// ClearLogo clears the value of the "logo" field.
func (m *ChainBaseMutation) ClearLogo() {
	m.logo = nil
	m.clearedFields[chainbase.FieldLogo] = struct{}{}
}

// LogoCleared returns if the "logo" field was cleared in this mutation.
func (m *ChainBaseMutation) LogoCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldLogo]
	return ok
}

// ResetLogo resets all changes to the "logo" field.
func (m *ChainBaseMutation) ResetLogo() {
	m.logo = nil
	delete(m.clearedFields, chainbase.FieldLogo)
}

// SetNativeUnit sets the "native_unit" field.
func (m *ChainBaseMutation) SetNativeUnit(s string) {
	m.native_unit = &s
}

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

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

// ClearNativeUnit clears the value of the "native_unit" field.
func (m *ChainBaseMutation) ClearNativeUnit() {
	m.native_unit = nil
	m.clearedFields[chainbase.FieldNativeUnit] = struct{}{}
}

// NativeUnitCleared returns if the "native_unit" field was cleared in this mutation.
func (m *ChainBaseMutation) NativeUnitCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldNativeUnit]
	return ok
}

// ResetNativeUnit resets all changes to the "native_unit" field.
func (m *ChainBaseMutation) ResetNativeUnit() {
	m.native_unit = nil
	delete(m.clearedFields, chainbase.FieldNativeUnit)
}

// SetAtomicUnit sets the "atomic_unit" field.
func (m *ChainBaseMutation) SetAtomicUnit(s string) {
	m.atomic_unit = &s
}

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

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

// ClearAtomicUnit clears the value of the "atomic_unit" field.
func (m *ChainBaseMutation) ClearAtomicUnit() {
	m.atomic_unit = nil
	m.clearedFields[chainbase.FieldAtomicUnit] = struct{}{}
}

// AtomicUnitCleared returns if the "atomic_unit" field was cleared in this mutation.
func (m *ChainBaseMutation) AtomicUnitCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldAtomicUnit]
	return ok
}

// ResetAtomicUnit resets all changes to the "atomic_unit" field.
func (m *ChainBaseMutation) ResetAtomicUnit() {
	m.atomic_unit = nil
	delete(m.clearedFields, chainbase.FieldAtomicUnit)
}

// SetUnitExp sets the "unit_exp" field.
func (m *ChainBaseMutation) SetUnitExp(u uint32) {
	m.unit_exp = &u
	m.addunit_exp = nil
}

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

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

// AddUnitExp adds u to the "unit_exp" field.
func (m *ChainBaseMutation) AddUnitExp(u int32) {
	if m.addunit_exp != nil {
		*m.addunit_exp += u
	} else {
		m.addunit_exp = &u
	}
}

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

// ClearUnitExp clears the value of the "unit_exp" field.
func (m *ChainBaseMutation) ClearUnitExp() {
	m.unit_exp = nil
	m.addunit_exp = nil
	m.clearedFields[chainbase.FieldUnitExp] = struct{}{}
}

// UnitExpCleared returns if the "unit_exp" field was cleared in this mutation.
func (m *ChainBaseMutation) UnitExpCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldUnitExp]
	return ok
}

// ResetUnitExp resets all changes to the "unit_exp" field.
func (m *ChainBaseMutation) ResetUnitExp() {
	m.unit_exp = nil
	m.addunit_exp = nil
	delete(m.clearedFields, chainbase.FieldUnitExp)
}

// SetEnv sets the "env" field.
func (m *ChainBaseMutation) SetEnv(s string) {
	m.env = &s
}

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

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

// ClearEnv clears the value of the "env" field.
func (m *ChainBaseMutation) ClearEnv() {
	m.env = nil
	m.clearedFields[chainbase.FieldEnv] = struct{}{}
}

// EnvCleared returns if the "env" field was cleared in this mutation.
func (m *ChainBaseMutation) EnvCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldEnv]
	return ok
}

// ResetEnv resets all changes to the "env" field.
func (m *ChainBaseMutation) ResetEnv() {
	m.env = nil
	delete(m.clearedFields, chainbase.FieldEnv)
}

// SetChainID sets the "chain_id" field.
func (m *ChainBaseMutation) SetChainID(s string) {
	m.chain_id = &s
}

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

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

// ClearChainID clears the value of the "chain_id" field.
func (m *ChainBaseMutation) ClearChainID() {
	m.chain_id = nil
	m.clearedFields[chainbase.FieldChainID] = struct{}{}
}

// ChainIDCleared returns if the "chain_id" field was cleared in this mutation.
func (m *ChainBaseMutation) ChainIDCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldChainID]
	return ok
}

// ResetChainID resets all changes to the "chain_id" field.
func (m *ChainBaseMutation) ResetChainID() {
	m.chain_id = nil
	delete(m.clearedFields, chainbase.FieldChainID)
}

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

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

// ClearNickname clears the value of the "nickname" field.
func (m *ChainBaseMutation) ClearNickname() {
	m.nickname = nil
	m.clearedFields[chainbase.FieldNickname] = struct{}{}
}

// NicknameCleared returns if the "nickname" field was cleared in this mutation.
func (m *ChainBaseMutation) NicknameCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldNickname]
	return ok
}

// ResetNickname resets all changes to the "nickname" field.
func (m *ChainBaseMutation) ResetNickname() {
	m.nickname = nil
	delete(m.clearedFields, chainbase.FieldNickname)
}

// SetGasType sets the "gas_type" field.
func (m *ChainBaseMutation) SetGasType(s string) {
	m.gas_type = &s
}

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

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

// ClearGasType clears the value of the "gas_type" field.
func (m *ChainBaseMutation) ClearGasType() {
	m.gas_type = nil
	m.clearedFields[chainbase.FieldGasType] = struct{}{}
}

// GasTypeCleared returns if the "gas_type" field was cleared in this mutation.
func (m *ChainBaseMutation) GasTypeCleared() bool {
	_, ok := m.clearedFields[chainbase.FieldGasType]
	return ok
}

// ResetGasType resets all changes to the "gas_type" field.
func (m *ChainBaseMutation) ResetGasType() {
	m.gas_type = nil
	delete(m.clearedFields, chainbase.FieldGasType)
}

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

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

// Type returns the node type of this mutation (ChainBase).
func (m *ChainBaseMutation) 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 *ChainBaseMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.created_at != nil {
		fields = append(fields, chainbase.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, chainbase.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, chainbase.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, chainbase.FieldEntID)
	}
	if m.name != nil {
		fields = append(fields, chainbase.FieldName)
	}
	if m.logo != nil {
		fields = append(fields, chainbase.FieldLogo)
	}
	if m.native_unit != nil {
		fields = append(fields, chainbase.FieldNativeUnit)
	}
	if m.atomic_unit != nil {
		fields = append(fields, chainbase.FieldAtomicUnit)
	}
	if m.unit_exp != nil {
		fields = append(fields, chainbase.FieldUnitExp)
	}
	if m.env != nil {
		fields = append(fields, chainbase.FieldEnv)
	}
	if m.chain_id != nil {
		fields = append(fields, chainbase.FieldChainID)
	}
	if m.nickname != nil {
		fields = append(fields, chainbase.FieldNickname)
	}
	if m.gas_type != nil {
		fields = append(fields, chainbase.FieldGasType)
	}
	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 *ChainBaseMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case chainbase.FieldCreatedAt:
		return m.CreatedAt()
	case chainbase.FieldUpdatedAt:
		return m.UpdatedAt()
	case chainbase.FieldDeletedAt:
		return m.DeletedAt()
	case chainbase.FieldEntID:
		return m.EntID()
	case chainbase.FieldName:
		return m.Name()
	case chainbase.FieldLogo:
		return m.Logo()
	case chainbase.FieldNativeUnit:
		return m.NativeUnit()
	case chainbase.FieldAtomicUnit:
		return m.AtomicUnit()
	case chainbase.FieldUnitExp:
		return m.UnitExp()
	case chainbase.FieldEnv:
		return m.Env()
	case chainbase.FieldChainID:
		return m.ChainID()
	case chainbase.FieldNickname:
		return m.Nickname()
	case chainbase.FieldGasType:
		return m.GasType()
	}
	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 *ChainBaseMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case chainbase.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case chainbase.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case chainbase.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case chainbase.FieldEntID:
		return m.OldEntID(ctx)
	case chainbase.FieldName:
		return m.OldName(ctx)
	case chainbase.FieldLogo:
		return m.OldLogo(ctx)
	case chainbase.FieldNativeUnit:
		return m.OldNativeUnit(ctx)
	case chainbase.FieldAtomicUnit:
		return m.OldAtomicUnit(ctx)
	case chainbase.FieldUnitExp:
		return m.OldUnitExp(ctx)
	case chainbase.FieldEnv:
		return m.OldEnv(ctx)
	case chainbase.FieldChainID:
		return m.OldChainID(ctx)
	case chainbase.FieldNickname:
		return m.OldNickname(ctx)
	case chainbase.FieldGasType:
		return m.OldGasType(ctx)
	}
	return nil, fmt.Errorf("unknown ChainBase 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 *ChainBaseMutation) SetField(name string, value ent.Value) error {
	switch name {
	case chainbase.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case chainbase.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case chainbase.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case chainbase.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case chainbase.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case chainbase.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	case chainbase.FieldNativeUnit:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNativeUnit(v)
		return nil
	case chainbase.FieldAtomicUnit:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAtomicUnit(v)
		return nil
	case chainbase.FieldUnitExp:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUnitExp(v)
		return nil
	case chainbase.FieldEnv:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEnv(v)
		return nil
	case chainbase.FieldChainID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChainID(v)
		return nil
	case chainbase.FieldNickname:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNickname(v)
		return nil
	case chainbase.FieldGasType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetGasType(v)
		return nil
	}
	return fmt.Errorf("unknown ChainBase field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ChainBaseMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, chainbase.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, chainbase.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, chainbase.FieldDeletedAt)
	}
	if m.addunit_exp != nil {
		fields = append(fields, chainbase.FieldUnitExp)
	}
	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 *ChainBaseMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case chainbase.FieldCreatedAt:
		return m.AddedCreatedAt()
	case chainbase.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case chainbase.FieldDeletedAt:
		return m.AddedDeletedAt()
	case chainbase.FieldUnitExp:
		return m.AddedUnitExp()
	}
	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 *ChainBaseMutation) AddField(name string, value ent.Value) error {
	switch name {
	case chainbase.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case chainbase.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case chainbase.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	case chainbase.FieldUnitExp:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUnitExp(v)
		return nil
	}
	return fmt.Errorf("unknown ChainBase numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ChainBaseMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(chainbase.FieldName) {
		fields = append(fields, chainbase.FieldName)
	}
	if m.FieldCleared(chainbase.FieldLogo) {
		fields = append(fields, chainbase.FieldLogo)
	}
	if m.FieldCleared(chainbase.FieldNativeUnit) {
		fields = append(fields, chainbase.FieldNativeUnit)
	}
	if m.FieldCleared(chainbase.FieldAtomicUnit) {
		fields = append(fields, chainbase.FieldAtomicUnit)
	}
	if m.FieldCleared(chainbase.FieldUnitExp) {
		fields = append(fields, chainbase.FieldUnitExp)
	}
	if m.FieldCleared(chainbase.FieldEnv) {
		fields = append(fields, chainbase.FieldEnv)
	}
	if m.FieldCleared(chainbase.FieldChainID) {
		fields = append(fields, chainbase.FieldChainID)
	}
	if m.FieldCleared(chainbase.FieldNickname) {
		fields = append(fields, chainbase.FieldNickname)
	}
	if m.FieldCleared(chainbase.FieldGasType) {
		fields = append(fields, chainbase.FieldGasType)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ChainBaseMutation) 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 *ChainBaseMutation) ClearField(name string) error {
	switch name {
	case chainbase.FieldName:
		m.ClearName()
		return nil
	case chainbase.FieldLogo:
		m.ClearLogo()
		return nil
	case chainbase.FieldNativeUnit:
		m.ClearNativeUnit()
		return nil
	case chainbase.FieldAtomicUnit:
		m.ClearAtomicUnit()
		return nil
	case chainbase.FieldUnitExp:
		m.ClearUnitExp()
		return nil
	case chainbase.FieldEnv:
		m.ClearEnv()
		return nil
	case chainbase.FieldChainID:
		m.ClearChainID()
		return nil
	case chainbase.FieldNickname:
		m.ClearNickname()
		return nil
	case chainbase.FieldGasType:
		m.ClearGasType()
		return nil
	}
	return fmt.Errorf("unknown ChainBase 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 *ChainBaseMutation) ResetField(name string) error {
	switch name {
	case chainbase.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case chainbase.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case chainbase.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case chainbase.FieldEntID:
		m.ResetEntID()
		return nil
	case chainbase.FieldName:
		m.ResetName()
		return nil
	case chainbase.FieldLogo:
		m.ResetLogo()
		return nil
	case chainbase.FieldNativeUnit:
		m.ResetNativeUnit()
		return nil
	case chainbase.FieldAtomicUnit:
		m.ResetAtomicUnit()
		return nil
	case chainbase.FieldUnitExp:
		m.ResetUnitExp()
		return nil
	case chainbase.FieldEnv:
		m.ResetEnv()
		return nil
	case chainbase.FieldChainID:
		m.ResetChainID()
		return nil
	case chainbase.FieldNickname:
		m.ResetNickname()
		return nil
	case chainbase.FieldGasType:
		m.ResetGasType()
		return nil
	}
	return fmt.Errorf("unknown ChainBase field %s", name)
}

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

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

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

// CoinBaseMutation represents an operation that mutates the CoinBase nodes in the graph.
type CoinBaseMutation struct {
	config
	op              Op
	typ             string
	id              *uint32
	created_at      *uint32
	addcreated_at   *int32
	updated_at      *uint32
	addupdated_at   *int32
	deleted_at      *uint32
	adddeleted_at   *int32
	ent_id          *uuid.UUID
	name            *string
	logo            *string
	presale         *bool
	unit            *string
	env             *string
	reserved_amount *decimal.Decimal
	for_pay         *bool
	disabled        *bool
	clearedFields   map[string]struct{}
	done            bool
	oldValue        func(context.Context) (*CoinBase, error)
	predicates      []predicate.CoinBase
}

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

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

// newCoinBaseMutation creates new mutation for the CoinBase entity.
func newCoinBaseMutation(c config, op Op, opts ...coinbaseOption) *CoinBaseMutation {
	m := &CoinBaseMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinBase,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinBase sets the old CoinBase of the mutation.
func withCoinBase(node *CoinBase) coinbaseOption {
	return func(m *CoinBaseMutation) {
		m.oldValue = func(context.Context) (*CoinBase, 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 CoinBaseMutation) 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 CoinBaseMutation) 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 CoinBase entities.
func (m *CoinBaseMutation) SetID(id uint32) {
	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 *CoinBaseMutation) ID() (id uint32, 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 *CoinBaseMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinBase.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 *CoinBaseMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinBaseMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinBaseMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinBaseMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinBaseMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinBaseMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinBaseMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinBaseMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinBaseMutation) ResetEntID() {
	m.ent_id = nil
}

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

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

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

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

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

// SetLogo sets the "logo" field.
func (m *CoinBaseMutation) SetLogo(s string) {
	m.logo = &s
}

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

// ClearLogo clears the value of the "logo" field.
func (m *CoinBaseMutation) ClearLogo() {
	m.logo = nil
	m.clearedFields[coinbase.FieldLogo] = struct{}{}
}

// LogoCleared returns if the "logo" field was cleared in this mutation.
func (m *CoinBaseMutation) LogoCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldLogo]
	return ok
}

// ResetLogo resets all changes to the "logo" field.
func (m *CoinBaseMutation) ResetLogo() {
	m.logo = nil
	delete(m.clearedFields, coinbase.FieldLogo)
}

// SetPresale sets the "presale" field.
func (m *CoinBaseMutation) SetPresale(b bool) {
	m.presale = &b
}

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

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

// ClearPresale clears the value of the "presale" field.
func (m *CoinBaseMutation) ClearPresale() {
	m.presale = nil
	m.clearedFields[coinbase.FieldPresale] = struct{}{}
}

// PresaleCleared returns if the "presale" field was cleared in this mutation.
func (m *CoinBaseMutation) PresaleCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldPresale]
	return ok
}

// ResetPresale resets all changes to the "presale" field.
func (m *CoinBaseMutation) ResetPresale() {
	m.presale = nil
	delete(m.clearedFields, coinbase.FieldPresale)
}

// SetUnit sets the "unit" field.
func (m *CoinBaseMutation) SetUnit(s string) {
	m.unit = &s
}

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

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

// ClearUnit clears the value of the "unit" field.
func (m *CoinBaseMutation) ClearUnit() {
	m.unit = nil
	m.clearedFields[coinbase.FieldUnit] = struct{}{}
}

// UnitCleared returns if the "unit" field was cleared in this mutation.
func (m *CoinBaseMutation) UnitCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldUnit]
	return ok
}

// ResetUnit resets all changes to the "unit" field.
func (m *CoinBaseMutation) ResetUnit() {
	m.unit = nil
	delete(m.clearedFields, coinbase.FieldUnit)
}

// SetEnv sets the "env" field.
func (m *CoinBaseMutation) SetEnv(s string) {
	m.env = &s
}

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

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

// ClearEnv clears the value of the "env" field.
func (m *CoinBaseMutation) ClearEnv() {
	m.env = nil
	m.clearedFields[coinbase.FieldEnv] = struct{}{}
}

// EnvCleared returns if the "env" field was cleared in this mutation.
func (m *CoinBaseMutation) EnvCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldEnv]
	return ok
}

// ResetEnv resets all changes to the "env" field.
func (m *CoinBaseMutation) ResetEnv() {
	m.env = nil
	delete(m.clearedFields, coinbase.FieldEnv)
}

// SetReservedAmount sets the "reserved_amount" field.
func (m *CoinBaseMutation) SetReservedAmount(d decimal.Decimal) {
	m.reserved_amount = &d
}

// ReservedAmount returns the value of the "reserved_amount" field in the mutation.
func (m *CoinBaseMutation) ReservedAmount() (r decimal.Decimal, exists bool) {
	v := m.reserved_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearReservedAmount clears the value of the "reserved_amount" field.
func (m *CoinBaseMutation) ClearReservedAmount() {
	m.reserved_amount = nil
	m.clearedFields[coinbase.FieldReservedAmount] = struct{}{}
}

// ReservedAmountCleared returns if the "reserved_amount" field was cleared in this mutation.
func (m *CoinBaseMutation) ReservedAmountCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldReservedAmount]
	return ok
}

// ResetReservedAmount resets all changes to the "reserved_amount" field.
func (m *CoinBaseMutation) ResetReservedAmount() {
	m.reserved_amount = nil
	delete(m.clearedFields, coinbase.FieldReservedAmount)
}

// SetForPay sets the "for_pay" field.
func (m *CoinBaseMutation) SetForPay(b bool) {
	m.for_pay = &b
}

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

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

// ClearForPay clears the value of the "for_pay" field.
func (m *CoinBaseMutation) ClearForPay() {
	m.for_pay = nil
	m.clearedFields[coinbase.FieldForPay] = struct{}{}
}

// ForPayCleared returns if the "for_pay" field was cleared in this mutation.
func (m *CoinBaseMutation) ForPayCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldForPay]
	return ok
}

// ResetForPay resets all changes to the "for_pay" field.
func (m *CoinBaseMutation) ResetForPay() {
	m.for_pay = nil
	delete(m.clearedFields, coinbase.FieldForPay)
}

// SetDisabled sets the "disabled" field.
func (m *CoinBaseMutation) SetDisabled(b bool) {
	m.disabled = &b
}

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

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

// ClearDisabled clears the value of the "disabled" field.
func (m *CoinBaseMutation) ClearDisabled() {
	m.disabled = nil
	m.clearedFields[coinbase.FieldDisabled] = struct{}{}
}

// DisabledCleared returns if the "disabled" field was cleared in this mutation.
func (m *CoinBaseMutation) DisabledCleared() bool {
	_, ok := m.clearedFields[coinbase.FieldDisabled]
	return ok
}

// ResetDisabled resets all changes to the "disabled" field.
func (m *CoinBaseMutation) ResetDisabled() {
	m.disabled = nil
	delete(m.clearedFields, coinbase.FieldDisabled)
}

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

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

// Type returns the node type of this mutation (CoinBase).
func (m *CoinBaseMutation) 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 *CoinBaseMutation) Fields() []string {
	fields := make([]string, 0, 12)
	if m.created_at != nil {
		fields = append(fields, coinbase.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinbase.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinbase.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinbase.FieldEntID)
	}
	if m.name != nil {
		fields = append(fields, coinbase.FieldName)
	}
	if m.logo != nil {
		fields = append(fields, coinbase.FieldLogo)
	}
	if m.presale != nil {
		fields = append(fields, coinbase.FieldPresale)
	}
	if m.unit != nil {
		fields = append(fields, coinbase.FieldUnit)
	}
	if m.env != nil {
		fields = append(fields, coinbase.FieldEnv)
	}
	if m.reserved_amount != nil {
		fields = append(fields, coinbase.FieldReservedAmount)
	}
	if m.for_pay != nil {
		fields = append(fields, coinbase.FieldForPay)
	}
	if m.disabled != nil {
		fields = append(fields, coinbase.FieldDisabled)
	}
	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 *CoinBaseMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinbase.FieldCreatedAt:
		return m.CreatedAt()
	case coinbase.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinbase.FieldDeletedAt:
		return m.DeletedAt()
	case coinbase.FieldEntID:
		return m.EntID()
	case coinbase.FieldName:
		return m.Name()
	case coinbase.FieldLogo:
		return m.Logo()
	case coinbase.FieldPresale:
		return m.Presale()
	case coinbase.FieldUnit:
		return m.Unit()
	case coinbase.FieldEnv:
		return m.Env()
	case coinbase.FieldReservedAmount:
		return m.ReservedAmount()
	case coinbase.FieldForPay:
		return m.ForPay()
	case coinbase.FieldDisabled:
		return m.Disabled()
	}
	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 *CoinBaseMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinbase.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinbase.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinbase.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinbase.FieldEntID:
		return m.OldEntID(ctx)
	case coinbase.FieldName:
		return m.OldName(ctx)
	case coinbase.FieldLogo:
		return m.OldLogo(ctx)
	case coinbase.FieldPresale:
		return m.OldPresale(ctx)
	case coinbase.FieldUnit:
		return m.OldUnit(ctx)
	case coinbase.FieldEnv:
		return m.OldEnv(ctx)
	case coinbase.FieldReservedAmount:
		return m.OldReservedAmount(ctx)
	case coinbase.FieldForPay:
		return m.OldForPay(ctx)
	case coinbase.FieldDisabled:
		return m.OldDisabled(ctx)
	}
	return nil, fmt.Errorf("unknown CoinBase 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 *CoinBaseMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinbase.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinbase.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinbase.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinbase.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinbase.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case coinbase.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	case coinbase.FieldPresale:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPresale(v)
		return nil
	case coinbase.FieldUnit:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUnit(v)
		return nil
	case coinbase.FieldEnv:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEnv(v)
		return nil
	case coinbase.FieldReservedAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReservedAmount(v)
		return nil
	case coinbase.FieldForPay:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetForPay(v)
		return nil
	case coinbase.FieldDisabled:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisabled(v)
		return nil
	}
	return fmt.Errorf("unknown CoinBase field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinBaseMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinbase.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinbase.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinbase.FieldDeletedAt)
	}
	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 *CoinBaseMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinbase.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinbase.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinbase.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinBaseMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinbase.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinbase.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinbase.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinBase numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinBaseMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinbase.FieldName) {
		fields = append(fields, coinbase.FieldName)
	}
	if m.FieldCleared(coinbase.FieldLogo) {
		fields = append(fields, coinbase.FieldLogo)
	}
	if m.FieldCleared(coinbase.FieldPresale) {
		fields = append(fields, coinbase.FieldPresale)
	}
	if m.FieldCleared(coinbase.FieldUnit) {
		fields = append(fields, coinbase.FieldUnit)
	}
	if m.FieldCleared(coinbase.FieldEnv) {
		fields = append(fields, coinbase.FieldEnv)
	}
	if m.FieldCleared(coinbase.FieldReservedAmount) {
		fields = append(fields, coinbase.FieldReservedAmount)
	}
	if m.FieldCleared(coinbase.FieldForPay) {
		fields = append(fields, coinbase.FieldForPay)
	}
	if m.FieldCleared(coinbase.FieldDisabled) {
		fields = append(fields, coinbase.FieldDisabled)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinBaseMutation) 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 *CoinBaseMutation) ClearField(name string) error {
	switch name {
	case coinbase.FieldName:
		m.ClearName()
		return nil
	case coinbase.FieldLogo:
		m.ClearLogo()
		return nil
	case coinbase.FieldPresale:
		m.ClearPresale()
		return nil
	case coinbase.FieldUnit:
		m.ClearUnit()
		return nil
	case coinbase.FieldEnv:
		m.ClearEnv()
		return nil
	case coinbase.FieldReservedAmount:
		m.ClearReservedAmount()
		return nil
	case coinbase.FieldForPay:
		m.ClearForPay()
		return nil
	case coinbase.FieldDisabled:
		m.ClearDisabled()
		return nil
	}
	return fmt.Errorf("unknown CoinBase 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 *CoinBaseMutation) ResetField(name string) error {
	switch name {
	case coinbase.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinbase.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinbase.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinbase.FieldEntID:
		m.ResetEntID()
		return nil
	case coinbase.FieldName:
		m.ResetName()
		return nil
	case coinbase.FieldLogo:
		m.ResetLogo()
		return nil
	case coinbase.FieldPresale:
		m.ResetPresale()
		return nil
	case coinbase.FieldUnit:
		m.ResetUnit()
		return nil
	case coinbase.FieldEnv:
		m.ResetEnv()
		return nil
	case coinbase.FieldReservedAmount:
		m.ResetReservedAmount()
		return nil
	case coinbase.FieldForPay:
		m.ResetForPay()
		return nil
	case coinbase.FieldDisabled:
		m.ResetDisabled()
		return nil
	}
	return fmt.Errorf("unknown CoinBase field %s", name)
}

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

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

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

// CoinDescriptionMutation represents an operation that mutates the CoinDescription nodes in the graph.
type CoinDescriptionMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	app_id        *uuid.UUID
	coin_type_id  *uuid.UUID
	used_for      *string
	title         *string
	message       *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*CoinDescription, error)
	predicates    []predicate.CoinDescription
}

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

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

// newCoinDescriptionMutation creates new mutation for the CoinDescription entity.
func newCoinDescriptionMutation(c config, op Op, opts ...coindescriptionOption) *CoinDescriptionMutation {
	m := &CoinDescriptionMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinDescription,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinDescription sets the old CoinDescription of the mutation.
func withCoinDescription(node *CoinDescription) coindescriptionOption {
	return func(m *CoinDescriptionMutation) {
		m.oldValue = func(context.Context) (*CoinDescription, 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 CoinDescriptionMutation) 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 CoinDescriptionMutation) 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 CoinDescription entities.
func (m *CoinDescriptionMutation) SetID(id uint32) {
	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 *CoinDescriptionMutation) ID() (id uint32, 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 *CoinDescriptionMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinDescription.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 *CoinDescriptionMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinDescriptionMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinDescriptionMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinDescriptionMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinDescriptionMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinDescriptionMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinDescriptionMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinDescriptionMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinDescriptionMutation) ResetEntID() {
	m.ent_id = nil
}

// SetAppID sets the "app_id" field.
func (m *CoinDescriptionMutation) SetAppID(u uuid.UUID) {
	m.app_id = &u
}

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

// OldAppID returns the old "app_id" field's value of the CoinDescription entity.
// If the CoinDescription object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CoinDescriptionMutation) OldAppID(ctx context.Context) (v uuid.UUID, 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 *CoinDescriptionMutation) ClearAppID() {
	m.app_id = nil
	m.clearedFields[coindescription.FieldAppID] = struct{}{}
}

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

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

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinDescriptionMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinDescriptionMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coindescription.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinDescriptionMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coindescription.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinDescriptionMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coindescription.FieldCoinTypeID)
}

// SetUsedFor sets the "used_for" field.
func (m *CoinDescriptionMutation) SetUsedFor(s string) {
	m.used_for = &s
}

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

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

// ClearUsedFor clears the value of the "used_for" field.
func (m *CoinDescriptionMutation) ClearUsedFor() {
	m.used_for = nil
	m.clearedFields[coindescription.FieldUsedFor] = struct{}{}
}

// UsedForCleared returns if the "used_for" field was cleared in this mutation.
func (m *CoinDescriptionMutation) UsedForCleared() bool {
	_, ok := m.clearedFields[coindescription.FieldUsedFor]
	return ok
}

// ResetUsedFor resets all changes to the "used_for" field.
func (m *CoinDescriptionMutation) ResetUsedFor() {
	m.used_for = nil
	delete(m.clearedFields, coindescription.FieldUsedFor)
}

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

// Title returns the value of the "title" field in the mutation.
func (m *CoinDescriptionMutation) 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 CoinDescription entity.
// If the CoinDescription object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *CoinDescriptionMutation) 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 *CoinDescriptionMutation) ClearTitle() {
	m.title = nil
	m.clearedFields[coindescription.FieldTitle] = struct{}{}
}

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

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

// SetMessage sets the "message" field.
func (m *CoinDescriptionMutation) SetMessage(s string) {
	m.message = &s
}

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

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

// ClearMessage clears the value of the "message" field.
func (m *CoinDescriptionMutation) ClearMessage() {
	m.message = nil
	m.clearedFields[coindescription.FieldMessage] = struct{}{}
}

// MessageCleared returns if the "message" field was cleared in this mutation.
func (m *CoinDescriptionMutation) MessageCleared() bool {
	_, ok := m.clearedFields[coindescription.FieldMessage]
	return ok
}

// ResetMessage resets all changes to the "message" field.
func (m *CoinDescriptionMutation) ResetMessage() {
	m.message = nil
	delete(m.clearedFields, coindescription.FieldMessage)
}

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

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

// Type returns the node type of this mutation (CoinDescription).
func (m *CoinDescriptionMutation) 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 *CoinDescriptionMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, coindescription.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coindescription.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coindescription.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coindescription.FieldEntID)
	}
	if m.app_id != nil {
		fields = append(fields, coindescription.FieldAppID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coindescription.FieldCoinTypeID)
	}
	if m.used_for != nil {
		fields = append(fields, coindescription.FieldUsedFor)
	}
	if m.title != nil {
		fields = append(fields, coindescription.FieldTitle)
	}
	if m.message != nil {
		fields = append(fields, coindescription.FieldMessage)
	}
	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 *CoinDescriptionMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coindescription.FieldCreatedAt:
		return m.CreatedAt()
	case coindescription.FieldUpdatedAt:
		return m.UpdatedAt()
	case coindescription.FieldDeletedAt:
		return m.DeletedAt()
	case coindescription.FieldEntID:
		return m.EntID()
	case coindescription.FieldAppID:
		return m.AppID()
	case coindescription.FieldCoinTypeID:
		return m.CoinTypeID()
	case coindescription.FieldUsedFor:
		return m.UsedFor()
	case coindescription.FieldTitle:
		return m.Title()
	case coindescription.FieldMessage:
		return m.Message()
	}
	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 *CoinDescriptionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coindescription.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coindescription.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coindescription.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coindescription.FieldEntID:
		return m.OldEntID(ctx)
	case coindescription.FieldAppID:
		return m.OldAppID(ctx)
	case coindescription.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coindescription.FieldUsedFor:
		return m.OldUsedFor(ctx)
	case coindescription.FieldTitle:
		return m.OldTitle(ctx)
	case coindescription.FieldMessage:
		return m.OldMessage(ctx)
	}
	return nil, fmt.Errorf("unknown CoinDescription 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 *CoinDescriptionMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coindescription.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coindescription.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coindescription.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coindescription.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coindescription.FieldAppID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAppID(v)
		return nil
	case coindescription.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coindescription.FieldUsedFor:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUsedFor(v)
		return nil
	case coindescription.FieldTitle:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTitle(v)
		return nil
	case coindescription.FieldMessage:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMessage(v)
		return nil
	}
	return fmt.Errorf("unknown CoinDescription field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinDescriptionMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coindescription.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coindescription.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coindescription.FieldDeletedAt)
	}
	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 *CoinDescriptionMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coindescription.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coindescription.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coindescription.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinDescriptionMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coindescription.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coindescription.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coindescription.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinDescription numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinDescriptionMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coindescription.FieldAppID) {
		fields = append(fields, coindescription.FieldAppID)
	}
	if m.FieldCleared(coindescription.FieldCoinTypeID) {
		fields = append(fields, coindescription.FieldCoinTypeID)
	}
	if m.FieldCleared(coindescription.FieldUsedFor) {
		fields = append(fields, coindescription.FieldUsedFor)
	}
	if m.FieldCleared(coindescription.FieldTitle) {
		fields = append(fields, coindescription.FieldTitle)
	}
	if m.FieldCleared(coindescription.FieldMessage) {
		fields = append(fields, coindescription.FieldMessage)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinDescriptionMutation) 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 *CoinDescriptionMutation) ClearField(name string) error {
	switch name {
	case coindescription.FieldAppID:
		m.ClearAppID()
		return nil
	case coindescription.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coindescription.FieldUsedFor:
		m.ClearUsedFor()
		return nil
	case coindescription.FieldTitle:
		m.ClearTitle()
		return nil
	case coindescription.FieldMessage:
		m.ClearMessage()
		return nil
	}
	return fmt.Errorf("unknown CoinDescription 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 *CoinDescriptionMutation) ResetField(name string) error {
	switch name {
	case coindescription.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coindescription.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coindescription.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coindescription.FieldEntID:
		m.ResetEntID()
		return nil
	case coindescription.FieldAppID:
		m.ResetAppID()
		return nil
	case coindescription.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coindescription.FieldUsedFor:
		m.ResetUsedFor()
		return nil
	case coindescription.FieldTitle:
		m.ResetTitle()
		return nil
	case coindescription.FieldMessage:
		m.ResetMessage()
		return nil
	}
	return fmt.Errorf("unknown CoinDescription field %s", name)
}

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

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

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

// CoinExtraMutation represents an operation that mutates the CoinExtra nodes in the graph.
type CoinExtraMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	coin_type_id  *uuid.UUID
	home_page     *string
	specs         *string
	stable_usd    *bool
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*CoinExtra, error)
	predicates    []predicate.CoinExtra
}

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

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

// newCoinExtraMutation creates new mutation for the CoinExtra entity.
func newCoinExtraMutation(c config, op Op, opts ...coinextraOption) *CoinExtraMutation {
	m := &CoinExtraMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinExtra,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinExtra sets the old CoinExtra of the mutation.
func withCoinExtra(node *CoinExtra) coinextraOption {
	return func(m *CoinExtraMutation) {
		m.oldValue = func(context.Context) (*CoinExtra, 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 CoinExtraMutation) 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 CoinExtraMutation) 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 CoinExtra entities.
func (m *CoinExtraMutation) SetID(id uint32) {
	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 *CoinExtraMutation) ID() (id uint32, 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 *CoinExtraMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinExtra.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 *CoinExtraMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinExtraMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinExtraMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinExtraMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinExtraMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinExtraMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinExtraMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinExtraMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinExtraMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinExtraMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinExtraMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coinextra.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinExtraMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coinextra.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinExtraMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coinextra.FieldCoinTypeID)
}

// SetHomePage sets the "home_page" field.
func (m *CoinExtraMutation) SetHomePage(s string) {
	m.home_page = &s
}

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

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

// ClearHomePage clears the value of the "home_page" field.
func (m *CoinExtraMutation) ClearHomePage() {
	m.home_page = nil
	m.clearedFields[coinextra.FieldHomePage] = struct{}{}
}

// HomePageCleared returns if the "home_page" field was cleared in this mutation.
func (m *CoinExtraMutation) HomePageCleared() bool {
	_, ok := m.clearedFields[coinextra.FieldHomePage]
	return ok
}

// ResetHomePage resets all changes to the "home_page" field.
func (m *CoinExtraMutation) ResetHomePage() {
	m.home_page = nil
	delete(m.clearedFields, coinextra.FieldHomePage)
}

// SetSpecs sets the "specs" field.
func (m *CoinExtraMutation) SetSpecs(s string) {
	m.specs = &s
}

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

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

// ClearSpecs clears the value of the "specs" field.
func (m *CoinExtraMutation) ClearSpecs() {
	m.specs = nil
	m.clearedFields[coinextra.FieldSpecs] = struct{}{}
}

// SpecsCleared returns if the "specs" field was cleared in this mutation.
func (m *CoinExtraMutation) SpecsCleared() bool {
	_, ok := m.clearedFields[coinextra.FieldSpecs]
	return ok
}

// ResetSpecs resets all changes to the "specs" field.
func (m *CoinExtraMutation) ResetSpecs() {
	m.specs = nil
	delete(m.clearedFields, coinextra.FieldSpecs)
}

// SetStableUsd sets the "stable_usd" field.
func (m *CoinExtraMutation) SetStableUsd(b bool) {
	m.stable_usd = &b
}

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

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

// ClearStableUsd clears the value of the "stable_usd" field.
func (m *CoinExtraMutation) ClearStableUsd() {
	m.stable_usd = nil
	m.clearedFields[coinextra.FieldStableUsd] = struct{}{}
}

// StableUsdCleared returns if the "stable_usd" field was cleared in this mutation.
func (m *CoinExtraMutation) StableUsdCleared() bool {
	_, ok := m.clearedFields[coinextra.FieldStableUsd]
	return ok
}

// ResetStableUsd resets all changes to the "stable_usd" field.
func (m *CoinExtraMutation) ResetStableUsd() {
	m.stable_usd = nil
	delete(m.clearedFields, coinextra.FieldStableUsd)
}

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

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

// Type returns the node type of this mutation (CoinExtra).
func (m *CoinExtraMutation) 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 *CoinExtraMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, coinextra.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinextra.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinextra.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinextra.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coinextra.FieldCoinTypeID)
	}
	if m.home_page != nil {
		fields = append(fields, coinextra.FieldHomePage)
	}
	if m.specs != nil {
		fields = append(fields, coinextra.FieldSpecs)
	}
	if m.stable_usd != nil {
		fields = append(fields, coinextra.FieldStableUsd)
	}
	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 *CoinExtraMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinextra.FieldCreatedAt:
		return m.CreatedAt()
	case coinextra.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinextra.FieldDeletedAt:
		return m.DeletedAt()
	case coinextra.FieldEntID:
		return m.EntID()
	case coinextra.FieldCoinTypeID:
		return m.CoinTypeID()
	case coinextra.FieldHomePage:
		return m.HomePage()
	case coinextra.FieldSpecs:
		return m.Specs()
	case coinextra.FieldStableUsd:
		return m.StableUsd()
	}
	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 *CoinExtraMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinextra.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinextra.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinextra.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinextra.FieldEntID:
		return m.OldEntID(ctx)
	case coinextra.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coinextra.FieldHomePage:
		return m.OldHomePage(ctx)
	case coinextra.FieldSpecs:
		return m.OldSpecs(ctx)
	case coinextra.FieldStableUsd:
		return m.OldStableUsd(ctx)
	}
	return nil, fmt.Errorf("unknown CoinExtra 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 *CoinExtraMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinextra.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinextra.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinextra.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinextra.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinextra.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coinextra.FieldHomePage:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHomePage(v)
		return nil
	case coinextra.FieldSpecs:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSpecs(v)
		return nil
	case coinextra.FieldStableUsd:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStableUsd(v)
		return nil
	}
	return fmt.Errorf("unknown CoinExtra field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinExtraMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinextra.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinextra.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinextra.FieldDeletedAt)
	}
	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 *CoinExtraMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinextra.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinextra.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinextra.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinExtraMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinextra.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinextra.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinextra.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinExtra numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinExtraMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinextra.FieldCoinTypeID) {
		fields = append(fields, coinextra.FieldCoinTypeID)
	}
	if m.FieldCleared(coinextra.FieldHomePage) {
		fields = append(fields, coinextra.FieldHomePage)
	}
	if m.FieldCleared(coinextra.FieldSpecs) {
		fields = append(fields, coinextra.FieldSpecs)
	}
	if m.FieldCleared(coinextra.FieldStableUsd) {
		fields = append(fields, coinextra.FieldStableUsd)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinExtraMutation) 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 *CoinExtraMutation) ClearField(name string) error {
	switch name {
	case coinextra.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coinextra.FieldHomePage:
		m.ClearHomePage()
		return nil
	case coinextra.FieldSpecs:
		m.ClearSpecs()
		return nil
	case coinextra.FieldStableUsd:
		m.ClearStableUsd()
		return nil
	}
	return fmt.Errorf("unknown CoinExtra 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 *CoinExtraMutation) ResetField(name string) error {
	switch name {
	case coinextra.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinextra.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinextra.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinextra.FieldEntID:
		m.ResetEntID()
		return nil
	case coinextra.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coinextra.FieldHomePage:
		m.ResetHomePage()
		return nil
	case coinextra.FieldSpecs:
		m.ResetSpecs()
		return nil
	case coinextra.FieldStableUsd:
		m.ResetStableUsd()
		return nil
	}
	return fmt.Errorf("unknown CoinExtra field %s", name)
}

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

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

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

// CoinFiatMutation represents an operation that mutates the CoinFiat nodes in the graph.
type CoinFiatMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	coin_type_id  *uuid.UUID
	fiat_id       *uuid.UUID
	feed_type     *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*CoinFiat, error)
	predicates    []predicate.CoinFiat
}

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

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

// newCoinFiatMutation creates new mutation for the CoinFiat entity.
func newCoinFiatMutation(c config, op Op, opts ...coinfiatOption) *CoinFiatMutation {
	m := &CoinFiatMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinFiat,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinFiat sets the old CoinFiat of the mutation.
func withCoinFiat(node *CoinFiat) coinfiatOption {
	return func(m *CoinFiatMutation) {
		m.oldValue = func(context.Context) (*CoinFiat, 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 CoinFiatMutation) 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 CoinFiatMutation) 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 CoinFiat entities.
func (m *CoinFiatMutation) SetID(id uint32) {
	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 *CoinFiatMutation) ID() (id uint32, 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 *CoinFiatMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinFiat.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 *CoinFiatMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinFiatMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinFiatMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinFiatMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinFiatMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinFiatMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinFiatMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinFiatMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinFiatMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinFiatMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinFiatMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coinfiat.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinFiatMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coinfiat.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinFiatMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coinfiat.FieldCoinTypeID)
}

// SetFiatID sets the "fiat_id" field.
func (m *CoinFiatMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *CoinFiatMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[coinfiat.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *CoinFiatMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[coinfiat.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *CoinFiatMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, coinfiat.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *CoinFiatMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CoinFiatMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[coinfiat.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CoinFiatMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[coinfiat.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CoinFiatMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, coinfiat.FieldFeedType)
}

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

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

// Type returns the node type of this mutation (CoinFiat).
func (m *CoinFiatMutation) 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 *CoinFiatMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, coinfiat.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinfiat.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinfiat.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinfiat.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coinfiat.FieldCoinTypeID)
	}
	if m.fiat_id != nil {
		fields = append(fields, coinfiat.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, coinfiat.FieldFeedType)
	}
	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 *CoinFiatMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinfiat.FieldCreatedAt:
		return m.CreatedAt()
	case coinfiat.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinfiat.FieldDeletedAt:
		return m.DeletedAt()
	case coinfiat.FieldEntID:
		return m.EntID()
	case coinfiat.FieldCoinTypeID:
		return m.CoinTypeID()
	case coinfiat.FieldFiatID:
		return m.FiatID()
	case coinfiat.FieldFeedType:
		return m.FeedType()
	}
	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 *CoinFiatMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinfiat.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinfiat.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinfiat.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinfiat.FieldEntID:
		return m.OldEntID(ctx)
	case coinfiat.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coinfiat.FieldFiatID:
		return m.OldFiatID(ctx)
	case coinfiat.FieldFeedType:
		return m.OldFeedType(ctx)
	}
	return nil, fmt.Errorf("unknown CoinFiat 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 *CoinFiatMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinfiat.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinfiat.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinfiat.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinfiat.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinfiat.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coinfiat.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case coinfiat.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiat field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinFiatMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinfiat.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinfiat.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinfiat.FieldDeletedAt)
	}
	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 *CoinFiatMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinfiat.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinfiat.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinfiat.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinFiatMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinfiat.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinfiat.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinfiat.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiat numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinFiatMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinfiat.FieldCoinTypeID) {
		fields = append(fields, coinfiat.FieldCoinTypeID)
	}
	if m.FieldCleared(coinfiat.FieldFiatID) {
		fields = append(fields, coinfiat.FieldFiatID)
	}
	if m.FieldCleared(coinfiat.FieldFeedType) {
		fields = append(fields, coinfiat.FieldFeedType)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinFiatMutation) 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 *CoinFiatMutation) ClearField(name string) error {
	switch name {
	case coinfiat.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coinfiat.FieldFiatID:
		m.ClearFiatID()
		return nil
	case coinfiat.FieldFeedType:
		m.ClearFeedType()
		return nil
	}
	return fmt.Errorf("unknown CoinFiat 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 *CoinFiatMutation) ResetField(name string) error {
	switch name {
	case coinfiat.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinfiat.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinfiat.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinfiat.FieldEntID:
		m.ResetEntID()
		return nil
	case coinfiat.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coinfiat.FieldFiatID:
		m.ResetFiatID()
		return nil
	case coinfiat.FieldFeedType:
		m.ResetFeedType()
		return nil
	}
	return fmt.Errorf("unknown CoinFiat field %s", name)
}

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

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

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

// CoinFiatCurrencyMutation represents an operation that mutates the CoinFiatCurrency nodes in the graph.
type CoinFiatCurrencyMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	coin_type_id      *uuid.UUID
	fiat_id           *uuid.UUID
	feed_type         *string
	market_value_low  *decimal.Decimal
	market_value_high *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*CoinFiatCurrency, error)
	predicates        []predicate.CoinFiatCurrency
}

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

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

// newCoinFiatCurrencyMutation creates new mutation for the CoinFiatCurrency entity.
func newCoinFiatCurrencyMutation(c config, op Op, opts ...coinfiatcurrencyOption) *CoinFiatCurrencyMutation {
	m := &CoinFiatCurrencyMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinFiatCurrency,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinFiatCurrency sets the old CoinFiatCurrency of the mutation.
func withCoinFiatCurrency(node *CoinFiatCurrency) coinfiatcurrencyOption {
	return func(m *CoinFiatCurrencyMutation) {
		m.oldValue = func(context.Context) (*CoinFiatCurrency, 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 CoinFiatCurrencyMutation) 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 CoinFiatCurrencyMutation) 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 CoinFiatCurrency entities.
func (m *CoinFiatCurrencyMutation) SetID(id uint32) {
	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 *CoinFiatCurrencyMutation) ID() (id uint32, 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 *CoinFiatCurrencyMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinFiatCurrency.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 *CoinFiatCurrencyMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinFiatCurrencyMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinFiatCurrencyMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinFiatCurrencyMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinFiatCurrencyMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinFiatCurrencyMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinFiatCurrencyMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinFiatCurrencyMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinFiatCurrencyMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinFiatCurrencyMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinFiatCurrencyMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coinfiatcurrency.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinFiatCurrencyMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrency.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinFiatCurrencyMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coinfiatcurrency.FieldCoinTypeID)
}

// SetFiatID sets the "fiat_id" field.
func (m *CoinFiatCurrencyMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *CoinFiatCurrencyMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[coinfiatcurrency.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *CoinFiatCurrencyMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrency.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *CoinFiatCurrencyMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, coinfiatcurrency.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *CoinFiatCurrencyMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CoinFiatCurrencyMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[coinfiatcurrency.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CoinFiatCurrencyMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrency.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CoinFiatCurrencyMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, coinfiatcurrency.FieldFeedType)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *CoinFiatCurrencyMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *CoinFiatCurrencyMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *CoinFiatCurrencyMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[coinfiatcurrency.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *CoinFiatCurrencyMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrency.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *CoinFiatCurrencyMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, coinfiatcurrency.FieldMarketValueLow)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *CoinFiatCurrencyMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *CoinFiatCurrencyMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *CoinFiatCurrencyMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[coinfiatcurrency.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *CoinFiatCurrencyMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrency.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *CoinFiatCurrencyMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, coinfiatcurrency.FieldMarketValueHigh)
}

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

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

// Type returns the node type of this mutation (CoinFiatCurrency).
func (m *CoinFiatCurrencyMutation) 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 *CoinFiatCurrencyMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, coinfiatcurrency.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinfiatcurrency.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinfiatcurrency.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinfiatcurrency.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coinfiatcurrency.FieldCoinTypeID)
	}
	if m.fiat_id != nil {
		fields = append(fields, coinfiatcurrency.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, coinfiatcurrency.FieldFeedType)
	}
	if m.market_value_low != nil {
		fields = append(fields, coinfiatcurrency.FieldMarketValueLow)
	}
	if m.market_value_high != nil {
		fields = append(fields, coinfiatcurrency.FieldMarketValueHigh)
	}
	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 *CoinFiatCurrencyMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		return m.CreatedAt()
	case coinfiatcurrency.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinfiatcurrency.FieldDeletedAt:
		return m.DeletedAt()
	case coinfiatcurrency.FieldEntID:
		return m.EntID()
	case coinfiatcurrency.FieldCoinTypeID:
		return m.CoinTypeID()
	case coinfiatcurrency.FieldFiatID:
		return m.FiatID()
	case coinfiatcurrency.FieldFeedType:
		return m.FeedType()
	case coinfiatcurrency.FieldMarketValueLow:
		return m.MarketValueLow()
	case coinfiatcurrency.FieldMarketValueHigh:
		return m.MarketValueHigh()
	}
	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 *CoinFiatCurrencyMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinfiatcurrency.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinfiatcurrency.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinfiatcurrency.FieldEntID:
		return m.OldEntID(ctx)
	case coinfiatcurrency.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coinfiatcurrency.FieldFiatID:
		return m.OldFiatID(ctx)
	case coinfiatcurrency.FieldFeedType:
		return m.OldFeedType(ctx)
	case coinfiatcurrency.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	case coinfiatcurrency.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	}
	return nil, fmt.Errorf("unknown CoinFiatCurrency 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 *CoinFiatCurrencyMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinfiatcurrency.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinfiatcurrency.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinfiatcurrency.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinfiatcurrency.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coinfiatcurrency.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case coinfiatcurrency.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case coinfiatcurrency.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	case coinfiatcurrency.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrency field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinFiatCurrencyMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinfiatcurrency.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinfiatcurrency.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinfiatcurrency.FieldDeletedAt)
	}
	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 *CoinFiatCurrencyMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinfiatcurrency.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinfiatcurrency.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinFiatCurrencyMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinfiatcurrency.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinfiatcurrency.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrency numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinFiatCurrencyMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinfiatcurrency.FieldCoinTypeID) {
		fields = append(fields, coinfiatcurrency.FieldCoinTypeID)
	}
	if m.FieldCleared(coinfiatcurrency.FieldFiatID) {
		fields = append(fields, coinfiatcurrency.FieldFiatID)
	}
	if m.FieldCleared(coinfiatcurrency.FieldFeedType) {
		fields = append(fields, coinfiatcurrency.FieldFeedType)
	}
	if m.FieldCleared(coinfiatcurrency.FieldMarketValueLow) {
		fields = append(fields, coinfiatcurrency.FieldMarketValueLow)
	}
	if m.FieldCleared(coinfiatcurrency.FieldMarketValueHigh) {
		fields = append(fields, coinfiatcurrency.FieldMarketValueHigh)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinFiatCurrencyMutation) 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 *CoinFiatCurrencyMutation) ClearField(name string) error {
	switch name {
	case coinfiatcurrency.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coinfiatcurrency.FieldFiatID:
		m.ClearFiatID()
		return nil
	case coinfiatcurrency.FieldFeedType:
		m.ClearFeedType()
		return nil
	case coinfiatcurrency.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	case coinfiatcurrency.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrency 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 *CoinFiatCurrencyMutation) ResetField(name string) error {
	switch name {
	case coinfiatcurrency.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinfiatcurrency.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinfiatcurrency.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinfiatcurrency.FieldEntID:
		m.ResetEntID()
		return nil
	case coinfiatcurrency.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coinfiatcurrency.FieldFiatID:
		m.ResetFiatID()
		return nil
	case coinfiatcurrency.FieldFeedType:
		m.ResetFeedType()
		return nil
	case coinfiatcurrency.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	case coinfiatcurrency.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrency field %s", name)
}

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

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

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

// CoinFiatCurrencyHistoryMutation represents an operation that mutates the CoinFiatCurrencyHistory nodes in the graph.
type CoinFiatCurrencyHistoryMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	coin_type_id      *uuid.UUID
	fiat_id           *uuid.UUID
	feed_type         *string
	market_value_low  *decimal.Decimal
	market_value_high *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*CoinFiatCurrencyHistory, error)
	predicates        []predicate.CoinFiatCurrencyHistory
}

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

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

// newCoinFiatCurrencyHistoryMutation creates new mutation for the CoinFiatCurrencyHistory entity.
func newCoinFiatCurrencyHistoryMutation(c config, op Op, opts ...coinfiatcurrencyhistoryOption) *CoinFiatCurrencyHistoryMutation {
	m := &CoinFiatCurrencyHistoryMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinFiatCurrencyHistory,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinFiatCurrencyHistory sets the old CoinFiatCurrencyHistory of the mutation.
func withCoinFiatCurrencyHistory(node *CoinFiatCurrencyHistory) coinfiatcurrencyhistoryOption {
	return func(m *CoinFiatCurrencyHistoryMutation) {
		m.oldValue = func(context.Context) (*CoinFiatCurrencyHistory, 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 CoinFiatCurrencyHistoryMutation) 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 CoinFiatCurrencyHistoryMutation) 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 CoinFiatCurrencyHistory entities.
func (m *CoinFiatCurrencyHistoryMutation) SetID(id uint32) {
	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 *CoinFiatCurrencyHistoryMutation) ID() (id uint32, 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 *CoinFiatCurrencyHistoryMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinFiatCurrencyHistory.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 *CoinFiatCurrencyHistoryMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinFiatCurrencyHistoryMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinFiatCurrencyHistoryMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinFiatCurrencyHistoryMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinFiatCurrencyHistoryMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinFiatCurrencyHistoryMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinFiatCurrencyHistoryMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinFiatCurrencyHistoryMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinFiatCurrencyHistoryMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coinfiatcurrencyhistory.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrencyhistory.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coinfiatcurrencyhistory.FieldCoinTypeID)
}

// SetFiatID sets the "fiat_id" field.
func (m *CoinFiatCurrencyHistoryMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *CoinFiatCurrencyHistoryMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[coinfiatcurrencyhistory.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrencyhistory.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, coinfiatcurrencyhistory.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *CoinFiatCurrencyHistoryMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CoinFiatCurrencyHistoryMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[coinfiatcurrencyhistory.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrencyhistory.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, coinfiatcurrencyhistory.FieldFeedType)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *CoinFiatCurrencyHistoryMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *CoinFiatCurrencyHistoryMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *CoinFiatCurrencyHistoryMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[coinfiatcurrencyhistory.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrencyhistory.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, coinfiatcurrencyhistory.FieldMarketValueLow)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *CoinFiatCurrencyHistoryMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *CoinFiatCurrencyHistoryMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *CoinFiatCurrencyHistoryMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[coinfiatcurrencyhistory.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[coinfiatcurrencyhistory.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *CoinFiatCurrencyHistoryMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, coinfiatcurrencyhistory.FieldMarketValueHigh)
}

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

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

// Type returns the node type of this mutation (CoinFiatCurrencyHistory).
func (m *CoinFiatCurrencyHistoryMutation) 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 *CoinFiatCurrencyHistoryMutation) Fields() []string {
	fields := make([]string, 0, 9)
	if m.created_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldCoinTypeID)
	}
	if m.fiat_id != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldFeedType)
	}
	if m.market_value_low != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldMarketValueLow)
	}
	if m.market_value_high != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldMarketValueHigh)
	}
	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 *CoinFiatCurrencyHistoryMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		return m.CreatedAt()
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinfiatcurrencyhistory.FieldDeletedAt:
		return m.DeletedAt()
	case coinfiatcurrencyhistory.FieldEntID:
		return m.EntID()
	case coinfiatcurrencyhistory.FieldCoinTypeID:
		return m.CoinTypeID()
	case coinfiatcurrencyhistory.FieldFiatID:
		return m.FiatID()
	case coinfiatcurrencyhistory.FieldFeedType:
		return m.FeedType()
	case coinfiatcurrencyhistory.FieldMarketValueLow:
		return m.MarketValueLow()
	case coinfiatcurrencyhistory.FieldMarketValueHigh:
		return m.MarketValueHigh()
	}
	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 *CoinFiatCurrencyHistoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinfiatcurrencyhistory.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinfiatcurrencyhistory.FieldEntID:
		return m.OldEntID(ctx)
	case coinfiatcurrencyhistory.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coinfiatcurrencyhistory.FieldFiatID:
		return m.OldFiatID(ctx)
	case coinfiatcurrencyhistory.FieldFeedType:
		return m.OldFeedType(ctx)
	case coinfiatcurrencyhistory.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	case coinfiatcurrencyhistory.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	}
	return nil, fmt.Errorf("unknown CoinFiatCurrencyHistory 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 *CoinFiatCurrencyHistoryMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinfiatcurrencyhistory.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinfiatcurrencyhistory.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinfiatcurrencyhistory.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coinfiatcurrencyhistory.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case coinfiatcurrencyhistory.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrencyHistory field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinFiatCurrencyHistoryMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinfiatcurrencyhistory.FieldDeletedAt)
	}
	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 *CoinFiatCurrencyHistoryMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinfiatcurrencyhistory.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CoinFiatCurrencyHistoryMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinfiatcurrencyhistory.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrencyHistory numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinFiatCurrencyHistoryMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinfiatcurrencyhistory.FieldCoinTypeID) {
		fields = append(fields, coinfiatcurrencyhistory.FieldCoinTypeID)
	}
	if m.FieldCleared(coinfiatcurrencyhistory.FieldFiatID) {
		fields = append(fields, coinfiatcurrencyhistory.FieldFiatID)
	}
	if m.FieldCleared(coinfiatcurrencyhistory.FieldFeedType) {
		fields = append(fields, coinfiatcurrencyhistory.FieldFeedType)
	}
	if m.FieldCleared(coinfiatcurrencyhistory.FieldMarketValueLow) {
		fields = append(fields, coinfiatcurrencyhistory.FieldMarketValueLow)
	}
	if m.FieldCleared(coinfiatcurrencyhistory.FieldMarketValueHigh) {
		fields = append(fields, coinfiatcurrencyhistory.FieldMarketValueHigh)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinFiatCurrencyHistoryMutation) 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 *CoinFiatCurrencyHistoryMutation) ClearField(name string) error {
	switch name {
	case coinfiatcurrencyhistory.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coinfiatcurrencyhistory.FieldFiatID:
		m.ClearFiatID()
		return nil
	case coinfiatcurrencyhistory.FieldFeedType:
		m.ClearFeedType()
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrencyHistory 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 *CoinFiatCurrencyHistoryMutation) ResetField(name string) error {
	switch name {
	case coinfiatcurrencyhistory.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinfiatcurrencyhistory.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinfiatcurrencyhistory.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinfiatcurrencyhistory.FieldEntID:
		m.ResetEntID()
		return nil
	case coinfiatcurrencyhistory.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coinfiatcurrencyhistory.FieldFiatID:
		m.ResetFiatID()
		return nil
	case coinfiatcurrencyhistory.FieldFeedType:
		m.ResetFeedType()
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	case coinfiatcurrencyhistory.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown CoinFiatCurrencyHistory field %s", name)
}

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

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

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

// CoinUsedForMutation represents an operation that mutates the CoinUsedFor nodes in the graph.
type CoinUsedForMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	coin_type_id  *uuid.UUID
	used_for      *string
	priority      *uint32
	addpriority   *int32
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*CoinUsedFor, error)
	predicates    []predicate.CoinUsedFor
}

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

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

// newCoinUsedForMutation creates new mutation for the CoinUsedFor entity.
func newCoinUsedForMutation(c config, op Op, opts ...coinusedforOption) *CoinUsedForMutation {
	m := &CoinUsedForMutation{
		config:        c,
		op:            op,
		typ:           TypeCoinUsedFor,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCoinUsedFor sets the old CoinUsedFor of the mutation.
func withCoinUsedFor(node *CoinUsedFor) coinusedforOption {
	return func(m *CoinUsedForMutation) {
		m.oldValue = func(context.Context) (*CoinUsedFor, 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 CoinUsedForMutation) 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 CoinUsedForMutation) 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 CoinUsedFor entities.
func (m *CoinUsedForMutation) SetID(id uint32) {
	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 *CoinUsedForMutation) ID() (id uint32, 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 *CoinUsedForMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CoinUsedFor.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 *CoinUsedForMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CoinUsedForMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CoinUsedForMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CoinUsedForMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CoinUsedForMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CoinUsedForMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CoinUsedForMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CoinUsedForMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CoinUsedForMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CoinUsedForMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CoinUsedForMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[coinusedfor.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CoinUsedForMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[coinusedfor.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CoinUsedForMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, coinusedfor.FieldCoinTypeID)
}

// SetUsedFor sets the "used_for" field.
func (m *CoinUsedForMutation) SetUsedFor(s string) {
	m.used_for = &s
}

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

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

// ClearUsedFor clears the value of the "used_for" field.
func (m *CoinUsedForMutation) ClearUsedFor() {
	m.used_for = nil
	m.clearedFields[coinusedfor.FieldUsedFor] = struct{}{}
}

// UsedForCleared returns if the "used_for" field was cleared in this mutation.
func (m *CoinUsedForMutation) UsedForCleared() bool {
	_, ok := m.clearedFields[coinusedfor.FieldUsedFor]
	return ok
}

// ResetUsedFor resets all changes to the "used_for" field.
func (m *CoinUsedForMutation) ResetUsedFor() {
	m.used_for = nil
	delete(m.clearedFields, coinusedfor.FieldUsedFor)
}

// SetPriority sets the "priority" field.
func (m *CoinUsedForMutation) SetPriority(u uint32) {
	m.priority = &u
	m.addpriority = nil
}

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

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

// AddPriority adds u to the "priority" field.
func (m *CoinUsedForMutation) AddPriority(u int32) {
	if m.addpriority != nil {
		*m.addpriority += u
	} else {
		m.addpriority = &u
	}
}

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

// ClearPriority clears the value of the "priority" field.
func (m *CoinUsedForMutation) ClearPriority() {
	m.priority = nil
	m.addpriority = nil
	m.clearedFields[coinusedfor.FieldPriority] = struct{}{}
}

// PriorityCleared returns if the "priority" field was cleared in this mutation.
func (m *CoinUsedForMutation) PriorityCleared() bool {
	_, ok := m.clearedFields[coinusedfor.FieldPriority]
	return ok
}

// ResetPriority resets all changes to the "priority" field.
func (m *CoinUsedForMutation) ResetPriority() {
	m.priority = nil
	m.addpriority = nil
	delete(m.clearedFields, coinusedfor.FieldPriority)
}

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

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

// Type returns the node type of this mutation (CoinUsedFor).
func (m *CoinUsedForMutation) 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 *CoinUsedForMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, coinusedfor.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, coinusedfor.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, coinusedfor.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, coinusedfor.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, coinusedfor.FieldCoinTypeID)
	}
	if m.used_for != nil {
		fields = append(fields, coinusedfor.FieldUsedFor)
	}
	if m.priority != nil {
		fields = append(fields, coinusedfor.FieldPriority)
	}
	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 *CoinUsedForMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case coinusedfor.FieldCreatedAt:
		return m.CreatedAt()
	case coinusedfor.FieldUpdatedAt:
		return m.UpdatedAt()
	case coinusedfor.FieldDeletedAt:
		return m.DeletedAt()
	case coinusedfor.FieldEntID:
		return m.EntID()
	case coinusedfor.FieldCoinTypeID:
		return m.CoinTypeID()
	case coinusedfor.FieldUsedFor:
		return m.UsedFor()
	case coinusedfor.FieldPriority:
		return m.Priority()
	}
	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 *CoinUsedForMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case coinusedfor.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case coinusedfor.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case coinusedfor.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case coinusedfor.FieldEntID:
		return m.OldEntID(ctx)
	case coinusedfor.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case coinusedfor.FieldUsedFor:
		return m.OldUsedFor(ctx)
	case coinusedfor.FieldPriority:
		return m.OldPriority(ctx)
	}
	return nil, fmt.Errorf("unknown CoinUsedFor 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 *CoinUsedForMutation) SetField(name string, value ent.Value) error {
	switch name {
	case coinusedfor.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case coinusedfor.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case coinusedfor.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case coinusedfor.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case coinusedfor.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case coinusedfor.FieldUsedFor:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUsedFor(v)
		return nil
	case coinusedfor.FieldPriority:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPriority(v)
		return nil
	}
	return fmt.Errorf("unknown CoinUsedFor field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CoinUsedForMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, coinusedfor.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, coinusedfor.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, coinusedfor.FieldDeletedAt)
	}
	if m.addpriority != nil {
		fields = append(fields, coinusedfor.FieldPriority)
	}
	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 *CoinUsedForMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case coinusedfor.FieldCreatedAt:
		return m.AddedCreatedAt()
	case coinusedfor.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case coinusedfor.FieldDeletedAt:
		return m.AddedDeletedAt()
	case coinusedfor.FieldPriority:
		return m.AddedPriority()
	}
	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 *CoinUsedForMutation) AddField(name string, value ent.Value) error {
	switch name {
	case coinusedfor.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case coinusedfor.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case coinusedfor.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	case coinusedfor.FieldPriority:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPriority(v)
		return nil
	}
	return fmt.Errorf("unknown CoinUsedFor numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CoinUsedForMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(coinusedfor.FieldCoinTypeID) {
		fields = append(fields, coinusedfor.FieldCoinTypeID)
	}
	if m.FieldCleared(coinusedfor.FieldUsedFor) {
		fields = append(fields, coinusedfor.FieldUsedFor)
	}
	if m.FieldCleared(coinusedfor.FieldPriority) {
		fields = append(fields, coinusedfor.FieldPriority)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CoinUsedForMutation) 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 *CoinUsedForMutation) ClearField(name string) error {
	switch name {
	case coinusedfor.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case coinusedfor.FieldUsedFor:
		m.ClearUsedFor()
		return nil
	case coinusedfor.FieldPriority:
		m.ClearPriority()
		return nil
	}
	return fmt.Errorf("unknown CoinUsedFor 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 *CoinUsedForMutation) ResetField(name string) error {
	switch name {
	case coinusedfor.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case coinusedfor.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case coinusedfor.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case coinusedfor.FieldEntID:
		m.ResetEntID()
		return nil
	case coinusedfor.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case coinusedfor.FieldUsedFor:
		m.ResetUsedFor()
		return nil
	case coinusedfor.FieldPriority:
		m.ResetPriority()
		return nil
	}
	return fmt.Errorf("unknown CoinUsedFor field %s", name)
}

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

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

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

// CurrencyMutation represents an operation that mutates the Currency nodes in the graph.
type CurrencyMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	coin_type_id      *uuid.UUID
	feed_type         *string
	market_value_high *decimal.Decimal
	market_value_low  *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*Currency, error)
	predicates        []predicate.Currency
}

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

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

// newCurrencyMutation creates new mutation for the Currency entity.
func newCurrencyMutation(c config, op Op, opts ...currencyOption) *CurrencyMutation {
	m := &CurrencyMutation{
		config:        c,
		op:            op,
		typ:           TypeCurrency,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCurrency sets the old Currency of the mutation.
func withCurrency(node *Currency) currencyOption {
	return func(m *CurrencyMutation) {
		m.oldValue = func(context.Context) (*Currency, 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 CurrencyMutation) 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 CurrencyMutation) 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 Currency entities.
func (m *CurrencyMutation) SetID(id uint32) {
	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 *CurrencyMutation) ID() (id uint32, 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 *CurrencyMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Currency.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 *CurrencyMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CurrencyMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CurrencyMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CurrencyMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CurrencyMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CurrencyMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CurrencyMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CurrencyMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CurrencyMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CurrencyMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CurrencyMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[currency.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CurrencyMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[currency.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CurrencyMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, currency.FieldCoinTypeID)
}

// SetFeedType sets the "feed_type" field.
func (m *CurrencyMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CurrencyMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[currency.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CurrencyMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[currency.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CurrencyMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, currency.FieldFeedType)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *CurrencyMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *CurrencyMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *CurrencyMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[currency.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *CurrencyMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[currency.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *CurrencyMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, currency.FieldMarketValueHigh)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *CurrencyMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *CurrencyMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *CurrencyMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[currency.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *CurrencyMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[currency.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *CurrencyMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, currency.FieldMarketValueLow)
}

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

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

// Type returns the node type of this mutation (Currency).
func (m *CurrencyMutation) 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 *CurrencyMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, currency.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, currency.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, currency.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, currency.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, currency.FieldCoinTypeID)
	}
	if m.feed_type != nil {
		fields = append(fields, currency.FieldFeedType)
	}
	if m.market_value_high != nil {
		fields = append(fields, currency.FieldMarketValueHigh)
	}
	if m.market_value_low != nil {
		fields = append(fields, currency.FieldMarketValueLow)
	}
	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 *CurrencyMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case currency.FieldCreatedAt:
		return m.CreatedAt()
	case currency.FieldUpdatedAt:
		return m.UpdatedAt()
	case currency.FieldDeletedAt:
		return m.DeletedAt()
	case currency.FieldEntID:
		return m.EntID()
	case currency.FieldCoinTypeID:
		return m.CoinTypeID()
	case currency.FieldFeedType:
		return m.FeedType()
	case currency.FieldMarketValueHigh:
		return m.MarketValueHigh()
	case currency.FieldMarketValueLow:
		return m.MarketValueLow()
	}
	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 *CurrencyMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case currency.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case currency.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case currency.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case currency.FieldEntID:
		return m.OldEntID(ctx)
	case currency.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case currency.FieldFeedType:
		return m.OldFeedType(ctx)
	case currency.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	case currency.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	}
	return nil, fmt.Errorf("unknown Currency 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 *CurrencyMutation) SetField(name string, value ent.Value) error {
	switch name {
	case currency.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case currency.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case currency.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case currency.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case currency.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case currency.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case currency.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	case currency.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	}
	return fmt.Errorf("unknown Currency field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CurrencyMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, currency.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, currency.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, currency.FieldDeletedAt)
	}
	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 *CurrencyMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case currency.FieldCreatedAt:
		return m.AddedCreatedAt()
	case currency.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case currency.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CurrencyMutation) AddField(name string, value ent.Value) error {
	switch name {
	case currency.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case currency.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case currency.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Currency numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CurrencyMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(currency.FieldCoinTypeID) {
		fields = append(fields, currency.FieldCoinTypeID)
	}
	if m.FieldCleared(currency.FieldFeedType) {
		fields = append(fields, currency.FieldFeedType)
	}
	if m.FieldCleared(currency.FieldMarketValueHigh) {
		fields = append(fields, currency.FieldMarketValueHigh)
	}
	if m.FieldCleared(currency.FieldMarketValueLow) {
		fields = append(fields, currency.FieldMarketValueLow)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CurrencyMutation) 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 *CurrencyMutation) ClearField(name string) error {
	switch name {
	case currency.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case currency.FieldFeedType:
		m.ClearFeedType()
		return nil
	case currency.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	case currency.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	}
	return fmt.Errorf("unknown Currency 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 *CurrencyMutation) ResetField(name string) error {
	switch name {
	case currency.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case currency.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case currency.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case currency.FieldEntID:
		m.ResetEntID()
		return nil
	case currency.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case currency.FieldFeedType:
		m.ResetFeedType()
		return nil
	case currency.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	case currency.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	}
	return fmt.Errorf("unknown Currency field %s", name)
}

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

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

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

// CurrencyFeedMutation represents an operation that mutates the CurrencyFeed nodes in the graph.
type CurrencyFeedMutation struct {
	config
	op             Op
	typ            string
	id             *uint32
	created_at     *uint32
	addcreated_at  *int32
	updated_at     *uint32
	addupdated_at  *int32
	deleted_at     *uint32
	adddeleted_at  *int32
	ent_id         *uuid.UUID
	coin_type_id   *uuid.UUID
	feed_type      *string
	feed_coin_name *string
	disabled       *bool
	clearedFields  map[string]struct{}
	done           bool
	oldValue       func(context.Context) (*CurrencyFeed, error)
	predicates     []predicate.CurrencyFeed
}

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

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

// newCurrencyFeedMutation creates new mutation for the CurrencyFeed entity.
func newCurrencyFeedMutation(c config, op Op, opts ...currencyfeedOption) *CurrencyFeedMutation {
	m := &CurrencyFeedMutation{
		config:        c,
		op:            op,
		typ:           TypeCurrencyFeed,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCurrencyFeed sets the old CurrencyFeed of the mutation.
func withCurrencyFeed(node *CurrencyFeed) currencyfeedOption {
	return func(m *CurrencyFeedMutation) {
		m.oldValue = func(context.Context) (*CurrencyFeed, 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 CurrencyFeedMutation) 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 CurrencyFeedMutation) 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 CurrencyFeed entities.
func (m *CurrencyFeedMutation) SetID(id uint32) {
	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 *CurrencyFeedMutation) ID() (id uint32, 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 *CurrencyFeedMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CurrencyFeed.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 *CurrencyFeedMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CurrencyFeedMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CurrencyFeedMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CurrencyFeedMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CurrencyFeedMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CurrencyFeedMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CurrencyFeedMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CurrencyFeedMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CurrencyFeedMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CurrencyFeedMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CurrencyFeedMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[currencyfeed.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CurrencyFeedMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[currencyfeed.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CurrencyFeedMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, currencyfeed.FieldCoinTypeID)
}

// SetFeedType sets the "feed_type" field.
func (m *CurrencyFeedMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CurrencyFeedMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[currencyfeed.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CurrencyFeedMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[currencyfeed.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CurrencyFeedMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, currencyfeed.FieldFeedType)
}

// SetFeedCoinName sets the "feed_coin_name" field.
func (m *CurrencyFeedMutation) SetFeedCoinName(s string) {
	m.feed_coin_name = &s
}

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

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

// ClearFeedCoinName clears the value of the "feed_coin_name" field.
func (m *CurrencyFeedMutation) ClearFeedCoinName() {
	m.feed_coin_name = nil
	m.clearedFields[currencyfeed.FieldFeedCoinName] = struct{}{}
}

// FeedCoinNameCleared returns if the "feed_coin_name" field was cleared in this mutation.
func (m *CurrencyFeedMutation) FeedCoinNameCleared() bool {
	_, ok := m.clearedFields[currencyfeed.FieldFeedCoinName]
	return ok
}

// ResetFeedCoinName resets all changes to the "feed_coin_name" field.
func (m *CurrencyFeedMutation) ResetFeedCoinName() {
	m.feed_coin_name = nil
	delete(m.clearedFields, currencyfeed.FieldFeedCoinName)
}

// SetDisabled sets the "disabled" field.
func (m *CurrencyFeedMutation) SetDisabled(b bool) {
	m.disabled = &b
}

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

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

// ClearDisabled clears the value of the "disabled" field.
func (m *CurrencyFeedMutation) ClearDisabled() {
	m.disabled = nil
	m.clearedFields[currencyfeed.FieldDisabled] = struct{}{}
}

// DisabledCleared returns if the "disabled" field was cleared in this mutation.
func (m *CurrencyFeedMutation) DisabledCleared() bool {
	_, ok := m.clearedFields[currencyfeed.FieldDisabled]
	return ok
}

// ResetDisabled resets all changes to the "disabled" field.
func (m *CurrencyFeedMutation) ResetDisabled() {
	m.disabled = nil
	delete(m.clearedFields, currencyfeed.FieldDisabled)
}

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

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

// Type returns the node type of this mutation (CurrencyFeed).
func (m *CurrencyFeedMutation) 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 *CurrencyFeedMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, currencyfeed.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, currencyfeed.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, currencyfeed.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, currencyfeed.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, currencyfeed.FieldCoinTypeID)
	}
	if m.feed_type != nil {
		fields = append(fields, currencyfeed.FieldFeedType)
	}
	if m.feed_coin_name != nil {
		fields = append(fields, currencyfeed.FieldFeedCoinName)
	}
	if m.disabled != nil {
		fields = append(fields, currencyfeed.FieldDisabled)
	}
	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 *CurrencyFeedMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case currencyfeed.FieldCreatedAt:
		return m.CreatedAt()
	case currencyfeed.FieldUpdatedAt:
		return m.UpdatedAt()
	case currencyfeed.FieldDeletedAt:
		return m.DeletedAt()
	case currencyfeed.FieldEntID:
		return m.EntID()
	case currencyfeed.FieldCoinTypeID:
		return m.CoinTypeID()
	case currencyfeed.FieldFeedType:
		return m.FeedType()
	case currencyfeed.FieldFeedCoinName:
		return m.FeedCoinName()
	case currencyfeed.FieldDisabled:
		return m.Disabled()
	}
	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 *CurrencyFeedMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case currencyfeed.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case currencyfeed.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case currencyfeed.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case currencyfeed.FieldEntID:
		return m.OldEntID(ctx)
	case currencyfeed.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case currencyfeed.FieldFeedType:
		return m.OldFeedType(ctx)
	case currencyfeed.FieldFeedCoinName:
		return m.OldFeedCoinName(ctx)
	case currencyfeed.FieldDisabled:
		return m.OldDisabled(ctx)
	}
	return nil, fmt.Errorf("unknown CurrencyFeed 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 *CurrencyFeedMutation) SetField(name string, value ent.Value) error {
	switch name {
	case currencyfeed.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case currencyfeed.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case currencyfeed.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case currencyfeed.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case currencyfeed.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case currencyfeed.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case currencyfeed.FieldFeedCoinName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedCoinName(v)
		return nil
	case currencyfeed.FieldDisabled:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisabled(v)
		return nil
	}
	return fmt.Errorf("unknown CurrencyFeed field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CurrencyFeedMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, currencyfeed.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, currencyfeed.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, currencyfeed.FieldDeletedAt)
	}
	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 *CurrencyFeedMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case currencyfeed.FieldCreatedAt:
		return m.AddedCreatedAt()
	case currencyfeed.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case currencyfeed.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CurrencyFeedMutation) AddField(name string, value ent.Value) error {
	switch name {
	case currencyfeed.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case currencyfeed.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case currencyfeed.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CurrencyFeed numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CurrencyFeedMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(currencyfeed.FieldCoinTypeID) {
		fields = append(fields, currencyfeed.FieldCoinTypeID)
	}
	if m.FieldCleared(currencyfeed.FieldFeedType) {
		fields = append(fields, currencyfeed.FieldFeedType)
	}
	if m.FieldCleared(currencyfeed.FieldFeedCoinName) {
		fields = append(fields, currencyfeed.FieldFeedCoinName)
	}
	if m.FieldCleared(currencyfeed.FieldDisabled) {
		fields = append(fields, currencyfeed.FieldDisabled)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CurrencyFeedMutation) 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 *CurrencyFeedMutation) ClearField(name string) error {
	switch name {
	case currencyfeed.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case currencyfeed.FieldFeedType:
		m.ClearFeedType()
		return nil
	case currencyfeed.FieldFeedCoinName:
		m.ClearFeedCoinName()
		return nil
	case currencyfeed.FieldDisabled:
		m.ClearDisabled()
		return nil
	}
	return fmt.Errorf("unknown CurrencyFeed 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 *CurrencyFeedMutation) ResetField(name string) error {
	switch name {
	case currencyfeed.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case currencyfeed.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case currencyfeed.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case currencyfeed.FieldEntID:
		m.ResetEntID()
		return nil
	case currencyfeed.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case currencyfeed.FieldFeedType:
		m.ResetFeedType()
		return nil
	case currencyfeed.FieldFeedCoinName:
		m.ResetFeedCoinName()
		return nil
	case currencyfeed.FieldDisabled:
		m.ResetDisabled()
		return nil
	}
	return fmt.Errorf("unknown CurrencyFeed field %s", name)
}

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

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

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

// CurrencyHistoryMutation represents an operation that mutates the CurrencyHistory nodes in the graph.
type CurrencyHistoryMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	coin_type_id      *uuid.UUID
	feed_type         *string
	market_value_high *decimal.Decimal
	market_value_low  *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*CurrencyHistory, error)
	predicates        []predicate.CurrencyHistory
}

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

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

// newCurrencyHistoryMutation creates new mutation for the CurrencyHistory entity.
func newCurrencyHistoryMutation(c config, op Op, opts ...currencyhistoryOption) *CurrencyHistoryMutation {
	m := &CurrencyHistoryMutation{
		config:        c,
		op:            op,
		typ:           TypeCurrencyHistory,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withCurrencyHistory sets the old CurrencyHistory of the mutation.
func withCurrencyHistory(node *CurrencyHistory) currencyhistoryOption {
	return func(m *CurrencyHistoryMutation) {
		m.oldValue = func(context.Context) (*CurrencyHistory, 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 CurrencyHistoryMutation) 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 CurrencyHistoryMutation) 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 CurrencyHistory entities.
func (m *CurrencyHistoryMutation) SetID(id uint32) {
	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 *CurrencyHistoryMutation) ID() (id uint32, 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 *CurrencyHistoryMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().CurrencyHistory.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 *CurrencyHistoryMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *CurrencyHistoryMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *CurrencyHistoryMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *CurrencyHistoryMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *CurrencyHistoryMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *CurrencyHistoryMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *CurrencyHistoryMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *CurrencyHistoryMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *CurrencyHistoryMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *CurrencyHistoryMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *CurrencyHistoryMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[currencyhistory.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *CurrencyHistoryMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[currencyhistory.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *CurrencyHistoryMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, currencyhistory.FieldCoinTypeID)
}

// SetFeedType sets the "feed_type" field.
func (m *CurrencyHistoryMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *CurrencyHistoryMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[currencyhistory.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *CurrencyHistoryMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[currencyhistory.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *CurrencyHistoryMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, currencyhistory.FieldFeedType)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *CurrencyHistoryMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *CurrencyHistoryMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *CurrencyHistoryMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[currencyhistory.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *CurrencyHistoryMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[currencyhistory.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *CurrencyHistoryMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, currencyhistory.FieldMarketValueHigh)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *CurrencyHistoryMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *CurrencyHistoryMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *CurrencyHistoryMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[currencyhistory.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *CurrencyHistoryMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[currencyhistory.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *CurrencyHistoryMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, currencyhistory.FieldMarketValueLow)
}

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

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

// Type returns the node type of this mutation (CurrencyHistory).
func (m *CurrencyHistoryMutation) 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 *CurrencyHistoryMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, currencyhistory.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, currencyhistory.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, currencyhistory.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, currencyhistory.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, currencyhistory.FieldCoinTypeID)
	}
	if m.feed_type != nil {
		fields = append(fields, currencyhistory.FieldFeedType)
	}
	if m.market_value_high != nil {
		fields = append(fields, currencyhistory.FieldMarketValueHigh)
	}
	if m.market_value_low != nil {
		fields = append(fields, currencyhistory.FieldMarketValueLow)
	}
	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 *CurrencyHistoryMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case currencyhistory.FieldCreatedAt:
		return m.CreatedAt()
	case currencyhistory.FieldUpdatedAt:
		return m.UpdatedAt()
	case currencyhistory.FieldDeletedAt:
		return m.DeletedAt()
	case currencyhistory.FieldEntID:
		return m.EntID()
	case currencyhistory.FieldCoinTypeID:
		return m.CoinTypeID()
	case currencyhistory.FieldFeedType:
		return m.FeedType()
	case currencyhistory.FieldMarketValueHigh:
		return m.MarketValueHigh()
	case currencyhistory.FieldMarketValueLow:
		return m.MarketValueLow()
	}
	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 *CurrencyHistoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case currencyhistory.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case currencyhistory.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case currencyhistory.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case currencyhistory.FieldEntID:
		return m.OldEntID(ctx)
	case currencyhistory.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case currencyhistory.FieldFeedType:
		return m.OldFeedType(ctx)
	case currencyhistory.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	case currencyhistory.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	}
	return nil, fmt.Errorf("unknown CurrencyHistory 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 *CurrencyHistoryMutation) SetField(name string, value ent.Value) error {
	switch name {
	case currencyhistory.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case currencyhistory.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case currencyhistory.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case currencyhistory.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case currencyhistory.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case currencyhistory.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case currencyhistory.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	case currencyhistory.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	}
	return fmt.Errorf("unknown CurrencyHistory field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *CurrencyHistoryMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, currencyhistory.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, currencyhistory.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, currencyhistory.FieldDeletedAt)
	}
	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 *CurrencyHistoryMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case currencyhistory.FieldCreatedAt:
		return m.AddedCreatedAt()
	case currencyhistory.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case currencyhistory.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *CurrencyHistoryMutation) AddField(name string, value ent.Value) error {
	switch name {
	case currencyhistory.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case currencyhistory.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case currencyhistory.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown CurrencyHistory numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *CurrencyHistoryMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(currencyhistory.FieldCoinTypeID) {
		fields = append(fields, currencyhistory.FieldCoinTypeID)
	}
	if m.FieldCleared(currencyhistory.FieldFeedType) {
		fields = append(fields, currencyhistory.FieldFeedType)
	}
	if m.FieldCleared(currencyhistory.FieldMarketValueHigh) {
		fields = append(fields, currencyhistory.FieldMarketValueHigh)
	}
	if m.FieldCleared(currencyhistory.FieldMarketValueLow) {
		fields = append(fields, currencyhistory.FieldMarketValueLow)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *CurrencyHistoryMutation) 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 *CurrencyHistoryMutation) ClearField(name string) error {
	switch name {
	case currencyhistory.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case currencyhistory.FieldFeedType:
		m.ClearFeedType()
		return nil
	case currencyhistory.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	case currencyhistory.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	}
	return fmt.Errorf("unknown CurrencyHistory 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 *CurrencyHistoryMutation) ResetField(name string) error {
	switch name {
	case currencyhistory.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case currencyhistory.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case currencyhistory.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case currencyhistory.FieldEntID:
		m.ResetEntID()
		return nil
	case currencyhistory.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case currencyhistory.FieldFeedType:
		m.ResetFeedType()
		return nil
	case currencyhistory.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	case currencyhistory.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	}
	return fmt.Errorf("unknown CurrencyHistory field %s", name)
}

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

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

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

// ExchangeRateMutation represents an operation that mutates the ExchangeRate nodes in the graph.
type ExchangeRateMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	app_id            *uuid.UUID
	coin_type_id      *uuid.UUID
	market_value      *decimal.Decimal
	settle_value      *decimal.Decimal
	settle_percent    *uint32
	addsettle_percent *int32
	settle_tips       *[]string
	setter            *uuid.UUID
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*ExchangeRate, error)
	predicates        []predicate.ExchangeRate
}

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

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

// newExchangeRateMutation creates new mutation for the ExchangeRate entity.
func newExchangeRateMutation(c config, op Op, opts ...exchangerateOption) *ExchangeRateMutation {
	m := &ExchangeRateMutation{
		config:        c,
		op:            op,
		typ:           TypeExchangeRate,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withExchangeRate sets the old ExchangeRate of the mutation.
func withExchangeRate(node *ExchangeRate) exchangerateOption {
	return func(m *ExchangeRateMutation) {
		m.oldValue = func(context.Context) (*ExchangeRate, 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 ExchangeRateMutation) 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 ExchangeRateMutation) 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 ExchangeRate entities.
func (m *ExchangeRateMutation) SetID(id uint32) {
	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 *ExchangeRateMutation) ID() (id uint32, 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 *ExchangeRateMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().ExchangeRate.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 *ExchangeRateMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *ExchangeRateMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *ExchangeRateMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *ExchangeRateMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *ExchangeRateMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *ExchangeRateMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *ExchangeRateMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *ExchangeRateMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *ExchangeRateMutation) ResetEntID() {
	m.ent_id = nil
}

// SetAppID sets the "app_id" field.
func (m *ExchangeRateMutation) SetAppID(u uuid.UUID) {
	m.app_id = &u
}

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

// OldAppID returns the old "app_id" field's value of the ExchangeRate entity.
// If the ExchangeRate object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *ExchangeRateMutation) OldAppID(ctx context.Context) (v uuid.UUID, 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 *ExchangeRateMutation) ClearAppID() {
	m.app_id = nil
	m.clearedFields[exchangerate.FieldAppID] = struct{}{}
}

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

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

// SetCoinTypeID sets the "coin_type_id" field.
func (m *ExchangeRateMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *ExchangeRateMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[exchangerate.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *ExchangeRateMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *ExchangeRateMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, exchangerate.FieldCoinTypeID)
}

// SetMarketValue sets the "market_value" field.
func (m *ExchangeRateMutation) SetMarketValue(d decimal.Decimal) {
	m.market_value = &d
}

// MarketValue returns the value of the "market_value" field in the mutation.
func (m *ExchangeRateMutation) MarketValue() (r decimal.Decimal, exists bool) {
	v := m.market_value
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValue clears the value of the "market_value" field.
func (m *ExchangeRateMutation) ClearMarketValue() {
	m.market_value = nil
	m.clearedFields[exchangerate.FieldMarketValue] = struct{}{}
}

// MarketValueCleared returns if the "market_value" field was cleared in this mutation.
func (m *ExchangeRateMutation) MarketValueCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldMarketValue]
	return ok
}

// ResetMarketValue resets all changes to the "market_value" field.
func (m *ExchangeRateMutation) ResetMarketValue() {
	m.market_value = nil
	delete(m.clearedFields, exchangerate.FieldMarketValue)
}

// SetSettleValue sets the "settle_value" field.
func (m *ExchangeRateMutation) SetSettleValue(d decimal.Decimal) {
	m.settle_value = &d
}

// SettleValue returns the value of the "settle_value" field in the mutation.
func (m *ExchangeRateMutation) SettleValue() (r decimal.Decimal, exists bool) {
	v := m.settle_value
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearSettleValue clears the value of the "settle_value" field.
func (m *ExchangeRateMutation) ClearSettleValue() {
	m.settle_value = nil
	m.clearedFields[exchangerate.FieldSettleValue] = struct{}{}
}

// SettleValueCleared returns if the "settle_value" field was cleared in this mutation.
func (m *ExchangeRateMutation) SettleValueCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldSettleValue]
	return ok
}

// ResetSettleValue resets all changes to the "settle_value" field.
func (m *ExchangeRateMutation) ResetSettleValue() {
	m.settle_value = nil
	delete(m.clearedFields, exchangerate.FieldSettleValue)
}

// SetSettlePercent sets the "settle_percent" field.
func (m *ExchangeRateMutation) SetSettlePercent(u uint32) {
	m.settle_percent = &u
	m.addsettle_percent = nil
}

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

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

// AddSettlePercent adds u to the "settle_percent" field.
func (m *ExchangeRateMutation) AddSettlePercent(u int32) {
	if m.addsettle_percent != nil {
		*m.addsettle_percent += u
	} else {
		m.addsettle_percent = &u
	}
}

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

// ClearSettlePercent clears the value of the "settle_percent" field.
func (m *ExchangeRateMutation) ClearSettlePercent() {
	m.settle_percent = nil
	m.addsettle_percent = nil
	m.clearedFields[exchangerate.FieldSettlePercent] = struct{}{}
}

// SettlePercentCleared returns if the "settle_percent" field was cleared in this mutation.
func (m *ExchangeRateMutation) SettlePercentCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldSettlePercent]
	return ok
}

// ResetSettlePercent resets all changes to the "settle_percent" field.
func (m *ExchangeRateMutation) ResetSettlePercent() {
	m.settle_percent = nil
	m.addsettle_percent = nil
	delete(m.clearedFields, exchangerate.FieldSettlePercent)
}

// SetSettleTips sets the "settle_tips" field.
func (m *ExchangeRateMutation) SetSettleTips(s []string) {
	m.settle_tips = &s
}

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

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

// ClearSettleTips clears the value of the "settle_tips" field.
func (m *ExchangeRateMutation) ClearSettleTips() {
	m.settle_tips = nil
	m.clearedFields[exchangerate.FieldSettleTips] = struct{}{}
}

// SettleTipsCleared returns if the "settle_tips" field was cleared in this mutation.
func (m *ExchangeRateMutation) SettleTipsCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldSettleTips]
	return ok
}

// ResetSettleTips resets all changes to the "settle_tips" field.
func (m *ExchangeRateMutation) ResetSettleTips() {
	m.settle_tips = nil
	delete(m.clearedFields, exchangerate.FieldSettleTips)
}

// SetSetter sets the "setter" field.
func (m *ExchangeRateMutation) SetSetter(u uuid.UUID) {
	m.setter = &u
}

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

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

// ClearSetter clears the value of the "setter" field.
func (m *ExchangeRateMutation) ClearSetter() {
	m.setter = nil
	m.clearedFields[exchangerate.FieldSetter] = struct{}{}
}

// SetterCleared returns if the "setter" field was cleared in this mutation.
func (m *ExchangeRateMutation) SetterCleared() bool {
	_, ok := m.clearedFields[exchangerate.FieldSetter]
	return ok
}

// ResetSetter resets all changes to the "setter" field.
func (m *ExchangeRateMutation) ResetSetter() {
	m.setter = nil
	delete(m.clearedFields, exchangerate.FieldSetter)
}

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

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

// Type returns the node type of this mutation (ExchangeRate).
func (m *ExchangeRateMutation) 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 *ExchangeRateMutation) Fields() []string {
	fields := make([]string, 0, 11)
	if m.created_at != nil {
		fields = append(fields, exchangerate.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, exchangerate.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, exchangerate.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, exchangerate.FieldEntID)
	}
	if m.app_id != nil {
		fields = append(fields, exchangerate.FieldAppID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, exchangerate.FieldCoinTypeID)
	}
	if m.market_value != nil {
		fields = append(fields, exchangerate.FieldMarketValue)
	}
	if m.settle_value != nil {
		fields = append(fields, exchangerate.FieldSettleValue)
	}
	if m.settle_percent != nil {
		fields = append(fields, exchangerate.FieldSettlePercent)
	}
	if m.settle_tips != nil {
		fields = append(fields, exchangerate.FieldSettleTips)
	}
	if m.setter != nil {
		fields = append(fields, exchangerate.FieldSetter)
	}
	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 *ExchangeRateMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case exchangerate.FieldCreatedAt:
		return m.CreatedAt()
	case exchangerate.FieldUpdatedAt:
		return m.UpdatedAt()
	case exchangerate.FieldDeletedAt:
		return m.DeletedAt()
	case exchangerate.FieldEntID:
		return m.EntID()
	case exchangerate.FieldAppID:
		return m.AppID()
	case exchangerate.FieldCoinTypeID:
		return m.CoinTypeID()
	case exchangerate.FieldMarketValue:
		return m.MarketValue()
	case exchangerate.FieldSettleValue:
		return m.SettleValue()
	case exchangerate.FieldSettlePercent:
		return m.SettlePercent()
	case exchangerate.FieldSettleTips:
		return m.SettleTips()
	case exchangerate.FieldSetter:
		return m.Setter()
	}
	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 *ExchangeRateMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case exchangerate.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case exchangerate.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case exchangerate.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case exchangerate.FieldEntID:
		return m.OldEntID(ctx)
	case exchangerate.FieldAppID:
		return m.OldAppID(ctx)
	case exchangerate.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case exchangerate.FieldMarketValue:
		return m.OldMarketValue(ctx)
	case exchangerate.FieldSettleValue:
		return m.OldSettleValue(ctx)
	case exchangerate.FieldSettlePercent:
		return m.OldSettlePercent(ctx)
	case exchangerate.FieldSettleTips:
		return m.OldSettleTips(ctx)
	case exchangerate.FieldSetter:
		return m.OldSetter(ctx)
	}
	return nil, fmt.Errorf("unknown ExchangeRate 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 *ExchangeRateMutation) SetField(name string, value ent.Value) error {
	switch name {
	case exchangerate.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case exchangerate.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case exchangerate.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case exchangerate.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case exchangerate.FieldAppID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAppID(v)
		return nil
	case exchangerate.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case exchangerate.FieldMarketValue:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValue(v)
		return nil
	case exchangerate.FieldSettleValue:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSettleValue(v)
		return nil
	case exchangerate.FieldSettlePercent:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSettlePercent(v)
		return nil
	case exchangerate.FieldSettleTips:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSettleTips(v)
		return nil
	case exchangerate.FieldSetter:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSetter(v)
		return nil
	}
	return fmt.Errorf("unknown ExchangeRate field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *ExchangeRateMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, exchangerate.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, exchangerate.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, exchangerate.FieldDeletedAt)
	}
	if m.addsettle_percent != nil {
		fields = append(fields, exchangerate.FieldSettlePercent)
	}
	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 *ExchangeRateMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case exchangerate.FieldCreatedAt:
		return m.AddedCreatedAt()
	case exchangerate.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case exchangerate.FieldDeletedAt:
		return m.AddedDeletedAt()
	case exchangerate.FieldSettlePercent:
		return m.AddedSettlePercent()
	}
	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 *ExchangeRateMutation) AddField(name string, value ent.Value) error {
	switch name {
	case exchangerate.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case exchangerate.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case exchangerate.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	case exchangerate.FieldSettlePercent:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddSettlePercent(v)
		return nil
	}
	return fmt.Errorf("unknown ExchangeRate numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *ExchangeRateMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(exchangerate.FieldAppID) {
		fields = append(fields, exchangerate.FieldAppID)
	}
	if m.FieldCleared(exchangerate.FieldCoinTypeID) {
		fields = append(fields, exchangerate.FieldCoinTypeID)
	}
	if m.FieldCleared(exchangerate.FieldMarketValue) {
		fields = append(fields, exchangerate.FieldMarketValue)
	}
	if m.FieldCleared(exchangerate.FieldSettleValue) {
		fields = append(fields, exchangerate.FieldSettleValue)
	}
	if m.FieldCleared(exchangerate.FieldSettlePercent) {
		fields = append(fields, exchangerate.FieldSettlePercent)
	}
	if m.FieldCleared(exchangerate.FieldSettleTips) {
		fields = append(fields, exchangerate.FieldSettleTips)
	}
	if m.FieldCleared(exchangerate.FieldSetter) {
		fields = append(fields, exchangerate.FieldSetter)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *ExchangeRateMutation) 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 *ExchangeRateMutation) ClearField(name string) error {
	switch name {
	case exchangerate.FieldAppID:
		m.ClearAppID()
		return nil
	case exchangerate.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case exchangerate.FieldMarketValue:
		m.ClearMarketValue()
		return nil
	case exchangerate.FieldSettleValue:
		m.ClearSettleValue()
		return nil
	case exchangerate.FieldSettlePercent:
		m.ClearSettlePercent()
		return nil
	case exchangerate.FieldSettleTips:
		m.ClearSettleTips()
		return nil
	case exchangerate.FieldSetter:
		m.ClearSetter()
		return nil
	}
	return fmt.Errorf("unknown ExchangeRate 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 *ExchangeRateMutation) ResetField(name string) error {
	switch name {
	case exchangerate.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case exchangerate.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case exchangerate.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case exchangerate.FieldEntID:
		m.ResetEntID()
		return nil
	case exchangerate.FieldAppID:
		m.ResetAppID()
		return nil
	case exchangerate.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case exchangerate.FieldMarketValue:
		m.ResetMarketValue()
		return nil
	case exchangerate.FieldSettleValue:
		m.ResetSettleValue()
		return nil
	case exchangerate.FieldSettlePercent:
		m.ResetSettlePercent()
		return nil
	case exchangerate.FieldSettleTips:
		m.ResetSettleTips()
		return nil
	case exchangerate.FieldSetter:
		m.ResetSetter()
		return nil
	}
	return fmt.Errorf("unknown ExchangeRate field %s", name)
}

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

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

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

// FiatMutation represents an operation that mutates the Fiat nodes in the graph.
type FiatMutation struct {
	config
	op            Op
	typ           string
	id            *uint32
	created_at    *uint32
	addcreated_at *int32
	updated_at    *uint32
	addupdated_at *int32
	deleted_at    *uint32
	adddeleted_at *int32
	ent_id        *uuid.UUID
	name          *string
	logo          *string
	unit          *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*Fiat, error)
	predicates    []predicate.Fiat
}

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

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

// newFiatMutation creates new mutation for the Fiat entity.
func newFiatMutation(c config, op Op, opts ...fiatOption) *FiatMutation {
	m := &FiatMutation{
		config:        c,
		op:            op,
		typ:           TypeFiat,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withFiat sets the old Fiat of the mutation.
func withFiat(node *Fiat) fiatOption {
	return func(m *FiatMutation) {
		m.oldValue = func(context.Context) (*Fiat, 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 FiatMutation) 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 FiatMutation) 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 Fiat entities.
func (m *FiatMutation) SetID(id uint32) {
	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 *FiatMutation) ID() (id uint32, 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 *FiatMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Fiat.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 *FiatMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *FiatMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *FiatMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *FiatMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *FiatMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *FiatMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *FiatMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *FiatMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *FiatMutation) ResetEntID() {
	m.ent_id = nil
}

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

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

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

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

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

// SetLogo sets the "logo" field.
func (m *FiatMutation) SetLogo(s string) {
	m.logo = &s
}

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

// ClearLogo clears the value of the "logo" field.
func (m *FiatMutation) ClearLogo() {
	m.logo = nil
	m.clearedFields[fiat.FieldLogo] = struct{}{}
}

// LogoCleared returns if the "logo" field was cleared in this mutation.
func (m *FiatMutation) LogoCleared() bool {
	_, ok := m.clearedFields[fiat.FieldLogo]
	return ok
}

// ResetLogo resets all changes to the "logo" field.
func (m *FiatMutation) ResetLogo() {
	m.logo = nil
	delete(m.clearedFields, fiat.FieldLogo)
}

// SetUnit sets the "unit" field.
func (m *FiatMutation) SetUnit(s string) {
	m.unit = &s
}

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

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

// ClearUnit clears the value of the "unit" field.
func (m *FiatMutation) ClearUnit() {
	m.unit = nil
	m.clearedFields[fiat.FieldUnit] = struct{}{}
}

// UnitCleared returns if the "unit" field was cleared in this mutation.
func (m *FiatMutation) UnitCleared() bool {
	_, ok := m.clearedFields[fiat.FieldUnit]
	return ok
}

// ResetUnit resets all changes to the "unit" field.
func (m *FiatMutation) ResetUnit() {
	m.unit = nil
	delete(m.clearedFields, fiat.FieldUnit)
}

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

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

// Type returns the node type of this mutation (Fiat).
func (m *FiatMutation) 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 *FiatMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, fiat.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, fiat.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, fiat.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, fiat.FieldEntID)
	}
	if m.name != nil {
		fields = append(fields, fiat.FieldName)
	}
	if m.logo != nil {
		fields = append(fields, fiat.FieldLogo)
	}
	if m.unit != nil {
		fields = append(fields, fiat.FieldUnit)
	}
	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 *FiatMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case fiat.FieldCreatedAt:
		return m.CreatedAt()
	case fiat.FieldUpdatedAt:
		return m.UpdatedAt()
	case fiat.FieldDeletedAt:
		return m.DeletedAt()
	case fiat.FieldEntID:
		return m.EntID()
	case fiat.FieldName:
		return m.Name()
	case fiat.FieldLogo:
		return m.Logo()
	case fiat.FieldUnit:
		return m.Unit()
	}
	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 *FiatMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case fiat.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case fiat.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case fiat.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case fiat.FieldEntID:
		return m.OldEntID(ctx)
	case fiat.FieldName:
		return m.OldName(ctx)
	case fiat.FieldLogo:
		return m.OldLogo(ctx)
	case fiat.FieldUnit:
		return m.OldUnit(ctx)
	}
	return nil, fmt.Errorf("unknown Fiat 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 *FiatMutation) SetField(name string, value ent.Value) error {
	switch name {
	case fiat.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case fiat.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case fiat.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case fiat.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case fiat.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case fiat.FieldLogo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLogo(v)
		return nil
	case fiat.FieldUnit:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUnit(v)
		return nil
	}
	return fmt.Errorf("unknown Fiat field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *FiatMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, fiat.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, fiat.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, fiat.FieldDeletedAt)
	}
	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 *FiatMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case fiat.FieldCreatedAt:
		return m.AddedCreatedAt()
	case fiat.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case fiat.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *FiatMutation) AddField(name string, value ent.Value) error {
	switch name {
	case fiat.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case fiat.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case fiat.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Fiat numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *FiatMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(fiat.FieldName) {
		fields = append(fields, fiat.FieldName)
	}
	if m.FieldCleared(fiat.FieldLogo) {
		fields = append(fields, fiat.FieldLogo)
	}
	if m.FieldCleared(fiat.FieldUnit) {
		fields = append(fields, fiat.FieldUnit)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *FiatMutation) 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 *FiatMutation) ClearField(name string) error {
	switch name {
	case fiat.FieldName:
		m.ClearName()
		return nil
	case fiat.FieldLogo:
		m.ClearLogo()
		return nil
	case fiat.FieldUnit:
		m.ClearUnit()
		return nil
	}
	return fmt.Errorf("unknown Fiat 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 *FiatMutation) ResetField(name string) error {
	switch name {
	case fiat.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case fiat.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case fiat.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case fiat.FieldEntID:
		m.ResetEntID()
		return nil
	case fiat.FieldName:
		m.ResetName()
		return nil
	case fiat.FieldLogo:
		m.ResetLogo()
		return nil
	case fiat.FieldUnit:
		m.ResetUnit()
		return nil
	}
	return fmt.Errorf("unknown Fiat field %s", name)
}

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

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

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

// FiatCurrencyMutation represents an operation that mutates the FiatCurrency nodes in the graph.
type FiatCurrencyMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	fiat_id           *uuid.UUID
	feed_type         *string
	market_value_low  *decimal.Decimal
	market_value_high *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*FiatCurrency, error)
	predicates        []predicate.FiatCurrency
}

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

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

// newFiatCurrencyMutation creates new mutation for the FiatCurrency entity.
func newFiatCurrencyMutation(c config, op Op, opts ...fiatcurrencyOption) *FiatCurrencyMutation {
	m := &FiatCurrencyMutation{
		config:        c,
		op:            op,
		typ:           TypeFiatCurrency,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withFiatCurrency sets the old FiatCurrency of the mutation.
func withFiatCurrency(node *FiatCurrency) fiatcurrencyOption {
	return func(m *FiatCurrencyMutation) {
		m.oldValue = func(context.Context) (*FiatCurrency, 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 FiatCurrencyMutation) 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 FiatCurrencyMutation) 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 FiatCurrency entities.
func (m *FiatCurrencyMutation) SetID(id uint32) {
	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 *FiatCurrencyMutation) ID() (id uint32, 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 *FiatCurrencyMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().FiatCurrency.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 *FiatCurrencyMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *FiatCurrencyMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *FiatCurrencyMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *FiatCurrencyMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *FiatCurrencyMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *FiatCurrencyMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *FiatCurrencyMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *FiatCurrencyMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *FiatCurrencyMutation) ResetEntID() {
	m.ent_id = nil
}

// SetFiatID sets the "fiat_id" field.
func (m *FiatCurrencyMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *FiatCurrencyMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[fiatcurrency.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *FiatCurrencyMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[fiatcurrency.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *FiatCurrencyMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, fiatcurrency.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *FiatCurrencyMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *FiatCurrencyMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[fiatcurrency.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *FiatCurrencyMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[fiatcurrency.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *FiatCurrencyMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, fiatcurrency.FieldFeedType)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *FiatCurrencyMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *FiatCurrencyMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *FiatCurrencyMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[fiatcurrency.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *FiatCurrencyMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[fiatcurrency.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *FiatCurrencyMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, fiatcurrency.FieldMarketValueLow)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *FiatCurrencyMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *FiatCurrencyMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *FiatCurrencyMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[fiatcurrency.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *FiatCurrencyMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[fiatcurrency.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *FiatCurrencyMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, fiatcurrency.FieldMarketValueHigh)
}

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

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

// Type returns the node type of this mutation (FiatCurrency).
func (m *FiatCurrencyMutation) 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 *FiatCurrencyMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, fiatcurrency.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, fiatcurrency.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, fiatcurrency.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, fiatcurrency.FieldEntID)
	}
	if m.fiat_id != nil {
		fields = append(fields, fiatcurrency.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, fiatcurrency.FieldFeedType)
	}
	if m.market_value_low != nil {
		fields = append(fields, fiatcurrency.FieldMarketValueLow)
	}
	if m.market_value_high != nil {
		fields = append(fields, fiatcurrency.FieldMarketValueHigh)
	}
	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 *FiatCurrencyMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		return m.CreatedAt()
	case fiatcurrency.FieldUpdatedAt:
		return m.UpdatedAt()
	case fiatcurrency.FieldDeletedAt:
		return m.DeletedAt()
	case fiatcurrency.FieldEntID:
		return m.EntID()
	case fiatcurrency.FieldFiatID:
		return m.FiatID()
	case fiatcurrency.FieldFeedType:
		return m.FeedType()
	case fiatcurrency.FieldMarketValueLow:
		return m.MarketValueLow()
	case fiatcurrency.FieldMarketValueHigh:
		return m.MarketValueHigh()
	}
	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 *FiatCurrencyMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case fiatcurrency.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case fiatcurrency.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case fiatcurrency.FieldEntID:
		return m.OldEntID(ctx)
	case fiatcurrency.FieldFiatID:
		return m.OldFiatID(ctx)
	case fiatcurrency.FieldFeedType:
		return m.OldFeedType(ctx)
	case fiatcurrency.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	case fiatcurrency.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	}
	return nil, fmt.Errorf("unknown FiatCurrency 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 *FiatCurrencyMutation) SetField(name string, value ent.Value) error {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case fiatcurrency.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case fiatcurrency.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case fiatcurrency.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case fiatcurrency.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case fiatcurrency.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case fiatcurrency.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	case fiatcurrency.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrency field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *FiatCurrencyMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, fiatcurrency.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, fiatcurrency.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, fiatcurrency.FieldDeletedAt)
	}
	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 *FiatCurrencyMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		return m.AddedCreatedAt()
	case fiatcurrency.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case fiatcurrency.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *FiatCurrencyMutation) AddField(name string, value ent.Value) error {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case fiatcurrency.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case fiatcurrency.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrency numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *FiatCurrencyMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(fiatcurrency.FieldFiatID) {
		fields = append(fields, fiatcurrency.FieldFiatID)
	}
	if m.FieldCleared(fiatcurrency.FieldFeedType) {
		fields = append(fields, fiatcurrency.FieldFeedType)
	}
	if m.FieldCleared(fiatcurrency.FieldMarketValueLow) {
		fields = append(fields, fiatcurrency.FieldMarketValueLow)
	}
	if m.FieldCleared(fiatcurrency.FieldMarketValueHigh) {
		fields = append(fields, fiatcurrency.FieldMarketValueHigh)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *FiatCurrencyMutation) 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 *FiatCurrencyMutation) ClearField(name string) error {
	switch name {
	case fiatcurrency.FieldFiatID:
		m.ClearFiatID()
		return nil
	case fiatcurrency.FieldFeedType:
		m.ClearFeedType()
		return nil
	case fiatcurrency.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	case fiatcurrency.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrency 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 *FiatCurrencyMutation) ResetField(name string) error {
	switch name {
	case fiatcurrency.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case fiatcurrency.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case fiatcurrency.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case fiatcurrency.FieldEntID:
		m.ResetEntID()
		return nil
	case fiatcurrency.FieldFiatID:
		m.ResetFiatID()
		return nil
	case fiatcurrency.FieldFeedType:
		m.ResetFeedType()
		return nil
	case fiatcurrency.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	case fiatcurrency.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrency field %s", name)
}

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

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

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

// FiatCurrencyFeedMutation represents an operation that mutates the FiatCurrencyFeed nodes in the graph.
type FiatCurrencyFeedMutation struct {
	config
	op             Op
	typ            string
	id             *uint32
	created_at     *uint32
	addcreated_at  *int32
	updated_at     *uint32
	addupdated_at  *int32
	deleted_at     *uint32
	adddeleted_at  *int32
	ent_id         *uuid.UUID
	fiat_id        *uuid.UUID
	feed_type      *string
	feed_fiat_name *string
	disabled       *bool
	clearedFields  map[string]struct{}
	done           bool
	oldValue       func(context.Context) (*FiatCurrencyFeed, error)
	predicates     []predicate.FiatCurrencyFeed
}

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

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

// newFiatCurrencyFeedMutation creates new mutation for the FiatCurrencyFeed entity.
func newFiatCurrencyFeedMutation(c config, op Op, opts ...fiatcurrencyfeedOption) *FiatCurrencyFeedMutation {
	m := &FiatCurrencyFeedMutation{
		config:        c,
		op:            op,
		typ:           TypeFiatCurrencyFeed,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withFiatCurrencyFeed sets the old FiatCurrencyFeed of the mutation.
func withFiatCurrencyFeed(node *FiatCurrencyFeed) fiatcurrencyfeedOption {
	return func(m *FiatCurrencyFeedMutation) {
		m.oldValue = func(context.Context) (*FiatCurrencyFeed, 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 FiatCurrencyFeedMutation) 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 FiatCurrencyFeedMutation) 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 FiatCurrencyFeed entities.
func (m *FiatCurrencyFeedMutation) SetID(id uint32) {
	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 *FiatCurrencyFeedMutation) ID() (id uint32, 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 *FiatCurrencyFeedMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().FiatCurrencyFeed.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 *FiatCurrencyFeedMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *FiatCurrencyFeedMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *FiatCurrencyFeedMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *FiatCurrencyFeedMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *FiatCurrencyFeedMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *FiatCurrencyFeedMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *FiatCurrencyFeedMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *FiatCurrencyFeedMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *FiatCurrencyFeedMutation) ResetEntID() {
	m.ent_id = nil
}

// SetFiatID sets the "fiat_id" field.
func (m *FiatCurrencyFeedMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *FiatCurrencyFeedMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[fiatcurrencyfeed.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *FiatCurrencyFeedMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyfeed.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *FiatCurrencyFeedMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, fiatcurrencyfeed.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *FiatCurrencyFeedMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *FiatCurrencyFeedMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[fiatcurrencyfeed.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *FiatCurrencyFeedMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyfeed.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *FiatCurrencyFeedMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, fiatcurrencyfeed.FieldFeedType)
}

// SetFeedFiatName sets the "feed_fiat_name" field.
func (m *FiatCurrencyFeedMutation) SetFeedFiatName(s string) {
	m.feed_fiat_name = &s
}

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

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

// ClearFeedFiatName clears the value of the "feed_fiat_name" field.
func (m *FiatCurrencyFeedMutation) ClearFeedFiatName() {
	m.feed_fiat_name = nil
	m.clearedFields[fiatcurrencyfeed.FieldFeedFiatName] = struct{}{}
}

// FeedFiatNameCleared returns if the "feed_fiat_name" field was cleared in this mutation.
func (m *FiatCurrencyFeedMutation) FeedFiatNameCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyfeed.FieldFeedFiatName]
	return ok
}

// ResetFeedFiatName resets all changes to the "feed_fiat_name" field.
func (m *FiatCurrencyFeedMutation) ResetFeedFiatName() {
	m.feed_fiat_name = nil
	delete(m.clearedFields, fiatcurrencyfeed.FieldFeedFiatName)
}

// SetDisabled sets the "disabled" field.
func (m *FiatCurrencyFeedMutation) SetDisabled(b bool) {
	m.disabled = &b
}

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

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

// ClearDisabled clears the value of the "disabled" field.
func (m *FiatCurrencyFeedMutation) ClearDisabled() {
	m.disabled = nil
	m.clearedFields[fiatcurrencyfeed.FieldDisabled] = struct{}{}
}

// DisabledCleared returns if the "disabled" field was cleared in this mutation.
func (m *FiatCurrencyFeedMutation) DisabledCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyfeed.FieldDisabled]
	return ok
}

// ResetDisabled resets all changes to the "disabled" field.
func (m *FiatCurrencyFeedMutation) ResetDisabled() {
	m.disabled = nil
	delete(m.clearedFields, fiatcurrencyfeed.FieldDisabled)
}

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

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

// Type returns the node type of this mutation (FiatCurrencyFeed).
func (m *FiatCurrencyFeedMutation) 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 *FiatCurrencyFeedMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, fiatcurrencyfeed.FieldEntID)
	}
	if m.fiat_id != nil {
		fields = append(fields, fiatcurrencyfeed.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, fiatcurrencyfeed.FieldFeedType)
	}
	if m.feed_fiat_name != nil {
		fields = append(fields, fiatcurrencyfeed.FieldFeedFiatName)
	}
	if m.disabled != nil {
		fields = append(fields, fiatcurrencyfeed.FieldDisabled)
	}
	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 *FiatCurrencyFeedMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		return m.CreatedAt()
	case fiatcurrencyfeed.FieldUpdatedAt:
		return m.UpdatedAt()
	case fiatcurrencyfeed.FieldDeletedAt:
		return m.DeletedAt()
	case fiatcurrencyfeed.FieldEntID:
		return m.EntID()
	case fiatcurrencyfeed.FieldFiatID:
		return m.FiatID()
	case fiatcurrencyfeed.FieldFeedType:
		return m.FeedType()
	case fiatcurrencyfeed.FieldFeedFiatName:
		return m.FeedFiatName()
	case fiatcurrencyfeed.FieldDisabled:
		return m.Disabled()
	}
	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 *FiatCurrencyFeedMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case fiatcurrencyfeed.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case fiatcurrencyfeed.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case fiatcurrencyfeed.FieldEntID:
		return m.OldEntID(ctx)
	case fiatcurrencyfeed.FieldFiatID:
		return m.OldFiatID(ctx)
	case fiatcurrencyfeed.FieldFeedType:
		return m.OldFeedType(ctx)
	case fiatcurrencyfeed.FieldFeedFiatName:
		return m.OldFeedFiatName(ctx)
	case fiatcurrencyfeed.FieldDisabled:
		return m.OldDisabled(ctx)
	}
	return nil, fmt.Errorf("unknown FiatCurrencyFeed 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 *FiatCurrencyFeedMutation) SetField(name string, value ent.Value) error {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case fiatcurrencyfeed.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case fiatcurrencyfeed.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case fiatcurrencyfeed.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case fiatcurrencyfeed.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case fiatcurrencyfeed.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case fiatcurrencyfeed.FieldFeedFiatName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedFiatName(v)
		return nil
	case fiatcurrencyfeed.FieldDisabled:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDisabled(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyFeed field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *FiatCurrencyFeedMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, fiatcurrencyfeed.FieldDeletedAt)
	}
	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 *FiatCurrencyFeedMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		return m.AddedCreatedAt()
	case fiatcurrencyfeed.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case fiatcurrencyfeed.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *FiatCurrencyFeedMutation) AddField(name string, value ent.Value) error {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case fiatcurrencyfeed.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case fiatcurrencyfeed.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyFeed numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *FiatCurrencyFeedMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(fiatcurrencyfeed.FieldFiatID) {
		fields = append(fields, fiatcurrencyfeed.FieldFiatID)
	}
	if m.FieldCleared(fiatcurrencyfeed.FieldFeedType) {
		fields = append(fields, fiatcurrencyfeed.FieldFeedType)
	}
	if m.FieldCleared(fiatcurrencyfeed.FieldFeedFiatName) {
		fields = append(fields, fiatcurrencyfeed.FieldFeedFiatName)
	}
	if m.FieldCleared(fiatcurrencyfeed.FieldDisabled) {
		fields = append(fields, fiatcurrencyfeed.FieldDisabled)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *FiatCurrencyFeedMutation) 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 *FiatCurrencyFeedMutation) ClearField(name string) error {
	switch name {
	case fiatcurrencyfeed.FieldFiatID:
		m.ClearFiatID()
		return nil
	case fiatcurrencyfeed.FieldFeedType:
		m.ClearFeedType()
		return nil
	case fiatcurrencyfeed.FieldFeedFiatName:
		m.ClearFeedFiatName()
		return nil
	case fiatcurrencyfeed.FieldDisabled:
		m.ClearDisabled()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyFeed 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 *FiatCurrencyFeedMutation) ResetField(name string) error {
	switch name {
	case fiatcurrencyfeed.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case fiatcurrencyfeed.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case fiatcurrencyfeed.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case fiatcurrencyfeed.FieldEntID:
		m.ResetEntID()
		return nil
	case fiatcurrencyfeed.FieldFiatID:
		m.ResetFiatID()
		return nil
	case fiatcurrencyfeed.FieldFeedType:
		m.ResetFeedType()
		return nil
	case fiatcurrencyfeed.FieldFeedFiatName:
		m.ResetFeedFiatName()
		return nil
	case fiatcurrencyfeed.FieldDisabled:
		m.ResetDisabled()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyFeed field %s", name)
}

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

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

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

// FiatCurrencyHistoryMutation represents an operation that mutates the FiatCurrencyHistory nodes in the graph.
type FiatCurrencyHistoryMutation struct {
	config
	op                Op
	typ               string
	id                *uint32
	created_at        *uint32
	addcreated_at     *int32
	updated_at        *uint32
	addupdated_at     *int32
	deleted_at        *uint32
	adddeleted_at     *int32
	ent_id            *uuid.UUID
	fiat_id           *uuid.UUID
	feed_type         *string
	market_value_low  *decimal.Decimal
	market_value_high *decimal.Decimal
	clearedFields     map[string]struct{}
	done              bool
	oldValue          func(context.Context) (*FiatCurrencyHistory, error)
	predicates        []predicate.FiatCurrencyHistory
}

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

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

// newFiatCurrencyHistoryMutation creates new mutation for the FiatCurrencyHistory entity.
func newFiatCurrencyHistoryMutation(c config, op Op, opts ...fiatcurrencyhistoryOption) *FiatCurrencyHistoryMutation {
	m := &FiatCurrencyHistoryMutation{
		config:        c,
		op:            op,
		typ:           TypeFiatCurrencyHistory,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withFiatCurrencyHistory sets the old FiatCurrencyHistory of the mutation.
func withFiatCurrencyHistory(node *FiatCurrencyHistory) fiatcurrencyhistoryOption {
	return func(m *FiatCurrencyHistoryMutation) {
		m.oldValue = func(context.Context) (*FiatCurrencyHistory, 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 FiatCurrencyHistoryMutation) 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 FiatCurrencyHistoryMutation) 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 FiatCurrencyHistory entities.
func (m *FiatCurrencyHistoryMutation) SetID(id uint32) {
	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 *FiatCurrencyHistoryMutation) ID() (id uint32, 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 *FiatCurrencyHistoryMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().FiatCurrencyHistory.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 *FiatCurrencyHistoryMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *FiatCurrencyHistoryMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *FiatCurrencyHistoryMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *FiatCurrencyHistoryMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *FiatCurrencyHistoryMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *FiatCurrencyHistoryMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *FiatCurrencyHistoryMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *FiatCurrencyHistoryMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *FiatCurrencyHistoryMutation) ResetEntID() {
	m.ent_id = nil
}

// SetFiatID sets the "fiat_id" field.
func (m *FiatCurrencyHistoryMutation) SetFiatID(u uuid.UUID) {
	m.fiat_id = &u
}

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

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

// ClearFiatID clears the value of the "fiat_id" field.
func (m *FiatCurrencyHistoryMutation) ClearFiatID() {
	m.fiat_id = nil
	m.clearedFields[fiatcurrencyhistory.FieldFiatID] = struct{}{}
}

// FiatIDCleared returns if the "fiat_id" field was cleared in this mutation.
func (m *FiatCurrencyHistoryMutation) FiatIDCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyhistory.FieldFiatID]
	return ok
}

// ResetFiatID resets all changes to the "fiat_id" field.
func (m *FiatCurrencyHistoryMutation) ResetFiatID() {
	m.fiat_id = nil
	delete(m.clearedFields, fiatcurrencyhistory.FieldFiatID)
}

// SetFeedType sets the "feed_type" field.
func (m *FiatCurrencyHistoryMutation) SetFeedType(s string) {
	m.feed_type = &s
}

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

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

// ClearFeedType clears the value of the "feed_type" field.
func (m *FiatCurrencyHistoryMutation) ClearFeedType() {
	m.feed_type = nil
	m.clearedFields[fiatcurrencyhistory.FieldFeedType] = struct{}{}
}

// FeedTypeCleared returns if the "feed_type" field was cleared in this mutation.
func (m *FiatCurrencyHistoryMutation) FeedTypeCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyhistory.FieldFeedType]
	return ok
}

// ResetFeedType resets all changes to the "feed_type" field.
func (m *FiatCurrencyHistoryMutation) ResetFeedType() {
	m.feed_type = nil
	delete(m.clearedFields, fiatcurrencyhistory.FieldFeedType)
}

// SetMarketValueLow sets the "market_value_low" field.
func (m *FiatCurrencyHistoryMutation) SetMarketValueLow(d decimal.Decimal) {
	m.market_value_low = &d
}

// MarketValueLow returns the value of the "market_value_low" field in the mutation.
func (m *FiatCurrencyHistoryMutation) MarketValueLow() (r decimal.Decimal, exists bool) {
	v := m.market_value_low
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueLow clears the value of the "market_value_low" field.
func (m *FiatCurrencyHistoryMutation) ClearMarketValueLow() {
	m.market_value_low = nil
	m.clearedFields[fiatcurrencyhistory.FieldMarketValueLow] = struct{}{}
}

// MarketValueLowCleared returns if the "market_value_low" field was cleared in this mutation.
func (m *FiatCurrencyHistoryMutation) MarketValueLowCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyhistory.FieldMarketValueLow]
	return ok
}

// ResetMarketValueLow resets all changes to the "market_value_low" field.
func (m *FiatCurrencyHistoryMutation) ResetMarketValueLow() {
	m.market_value_low = nil
	delete(m.clearedFields, fiatcurrencyhistory.FieldMarketValueLow)
}

// SetMarketValueHigh sets the "market_value_high" field.
func (m *FiatCurrencyHistoryMutation) SetMarketValueHigh(d decimal.Decimal) {
	m.market_value_high = &d
}

// MarketValueHigh returns the value of the "market_value_high" field in the mutation.
func (m *FiatCurrencyHistoryMutation) MarketValueHigh() (r decimal.Decimal, exists bool) {
	v := m.market_value_high
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearMarketValueHigh clears the value of the "market_value_high" field.
func (m *FiatCurrencyHistoryMutation) ClearMarketValueHigh() {
	m.market_value_high = nil
	m.clearedFields[fiatcurrencyhistory.FieldMarketValueHigh] = struct{}{}
}

// MarketValueHighCleared returns if the "market_value_high" field was cleared in this mutation.
func (m *FiatCurrencyHistoryMutation) MarketValueHighCleared() bool {
	_, ok := m.clearedFields[fiatcurrencyhistory.FieldMarketValueHigh]
	return ok
}

// ResetMarketValueHigh resets all changes to the "market_value_high" field.
func (m *FiatCurrencyHistoryMutation) ResetMarketValueHigh() {
	m.market_value_high = nil
	delete(m.clearedFields, fiatcurrencyhistory.FieldMarketValueHigh)
}

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

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

// Type returns the node type of this mutation (FiatCurrencyHistory).
func (m *FiatCurrencyHistoryMutation) 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 *FiatCurrencyHistoryMutation) Fields() []string {
	fields := make([]string, 0, 8)
	if m.created_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, fiatcurrencyhistory.FieldEntID)
	}
	if m.fiat_id != nil {
		fields = append(fields, fiatcurrencyhistory.FieldFiatID)
	}
	if m.feed_type != nil {
		fields = append(fields, fiatcurrencyhistory.FieldFeedType)
	}
	if m.market_value_low != nil {
		fields = append(fields, fiatcurrencyhistory.FieldMarketValueLow)
	}
	if m.market_value_high != nil {
		fields = append(fields, fiatcurrencyhistory.FieldMarketValueHigh)
	}
	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 *FiatCurrencyHistoryMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		return m.CreatedAt()
	case fiatcurrencyhistory.FieldUpdatedAt:
		return m.UpdatedAt()
	case fiatcurrencyhistory.FieldDeletedAt:
		return m.DeletedAt()
	case fiatcurrencyhistory.FieldEntID:
		return m.EntID()
	case fiatcurrencyhistory.FieldFiatID:
		return m.FiatID()
	case fiatcurrencyhistory.FieldFeedType:
		return m.FeedType()
	case fiatcurrencyhistory.FieldMarketValueLow:
		return m.MarketValueLow()
	case fiatcurrencyhistory.FieldMarketValueHigh:
		return m.MarketValueHigh()
	}
	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 *FiatCurrencyHistoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case fiatcurrencyhistory.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case fiatcurrencyhistory.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case fiatcurrencyhistory.FieldEntID:
		return m.OldEntID(ctx)
	case fiatcurrencyhistory.FieldFiatID:
		return m.OldFiatID(ctx)
	case fiatcurrencyhistory.FieldFeedType:
		return m.OldFeedType(ctx)
	case fiatcurrencyhistory.FieldMarketValueLow:
		return m.OldMarketValueLow(ctx)
	case fiatcurrencyhistory.FieldMarketValueHigh:
		return m.OldMarketValueHigh(ctx)
	}
	return nil, fmt.Errorf("unknown FiatCurrencyHistory 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 *FiatCurrencyHistoryMutation) SetField(name string, value ent.Value) error {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case fiatcurrencyhistory.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case fiatcurrencyhistory.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case fiatcurrencyhistory.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case fiatcurrencyhistory.FieldFiatID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFiatID(v)
		return nil
	case fiatcurrencyhistory.FieldFeedType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeedType(v)
		return nil
	case fiatcurrencyhistory.FieldMarketValueLow:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueLow(v)
		return nil
	case fiatcurrencyhistory.FieldMarketValueHigh:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetMarketValueHigh(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyHistory field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *FiatCurrencyHistoryMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, fiatcurrencyhistory.FieldDeletedAt)
	}
	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 *FiatCurrencyHistoryMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		return m.AddedCreatedAt()
	case fiatcurrencyhistory.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case fiatcurrencyhistory.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *FiatCurrencyHistoryMutation) AddField(name string, value ent.Value) error {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case fiatcurrencyhistory.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case fiatcurrencyhistory.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyHistory numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *FiatCurrencyHistoryMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(fiatcurrencyhistory.FieldFiatID) {
		fields = append(fields, fiatcurrencyhistory.FieldFiatID)
	}
	if m.FieldCleared(fiatcurrencyhistory.FieldFeedType) {
		fields = append(fields, fiatcurrencyhistory.FieldFeedType)
	}
	if m.FieldCleared(fiatcurrencyhistory.FieldMarketValueLow) {
		fields = append(fields, fiatcurrencyhistory.FieldMarketValueLow)
	}
	if m.FieldCleared(fiatcurrencyhistory.FieldMarketValueHigh) {
		fields = append(fields, fiatcurrencyhistory.FieldMarketValueHigh)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *FiatCurrencyHistoryMutation) 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 *FiatCurrencyHistoryMutation) ClearField(name string) error {
	switch name {
	case fiatcurrencyhistory.FieldFiatID:
		m.ClearFiatID()
		return nil
	case fiatcurrencyhistory.FieldFeedType:
		m.ClearFeedType()
		return nil
	case fiatcurrencyhistory.FieldMarketValueLow:
		m.ClearMarketValueLow()
		return nil
	case fiatcurrencyhistory.FieldMarketValueHigh:
		m.ClearMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyHistory 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 *FiatCurrencyHistoryMutation) ResetField(name string) error {
	switch name {
	case fiatcurrencyhistory.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case fiatcurrencyhistory.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case fiatcurrencyhistory.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case fiatcurrencyhistory.FieldEntID:
		m.ResetEntID()
		return nil
	case fiatcurrencyhistory.FieldFiatID:
		m.ResetFiatID()
		return nil
	case fiatcurrencyhistory.FieldFeedType:
		m.ResetFeedType()
		return nil
	case fiatcurrencyhistory.FieldMarketValueLow:
		m.ResetMarketValueLow()
		return nil
	case fiatcurrencyhistory.FieldMarketValueHigh:
		m.ResetMarketValueHigh()
		return nil
	}
	return fmt.Errorf("unknown FiatCurrencyHistory field %s", name)
}

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

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

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

// SettingMutation represents an operation that mutates the Setting nodes in the graph.
type SettingMutation struct {
	config
	op                             Op
	typ                            string
	id                             *uint32
	created_at                     *uint32
	addcreated_at                  *int32
	updated_at                     *uint32
	addupdated_at                  *int32
	deleted_at                     *uint32
	adddeleted_at                  *int32
	ent_id                         *uuid.UUID
	coin_type_id                   *uuid.UUID
	fee_coin_type_id               *uuid.UUID
	withdraw_fee_by_stable_usd     *bool
	withdraw_fee_amount            *decimal.Decimal
	collect_fee_amount             *decimal.Decimal
	hot_wallet_fee_amount          *decimal.Decimal
	low_fee_amount                 *decimal.Decimal
	hot_low_fee_amount             *decimal.Decimal
	hot_wallet_account_amount      *decimal.Decimal
	payment_account_collect_amount *decimal.Decimal
	least_transfer_amount          *decimal.Decimal
	need_memo                      *bool
	refresh_currency               *bool
	check_new_address_balance      *bool
	clearedFields                  map[string]struct{}
	done                           bool
	oldValue                       func(context.Context) (*Setting, error)
	predicates                     []predicate.Setting
}

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

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

// newSettingMutation creates new mutation for the Setting entity.
func newSettingMutation(c config, op Op, opts ...settingOption) *SettingMutation {
	m := &SettingMutation{
		config:        c,
		op:            op,
		typ:           TypeSetting,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withSetting sets the old Setting of the mutation.
func withSetting(node *Setting) settingOption {
	return func(m *SettingMutation) {
		m.oldValue = func(context.Context) (*Setting, 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 SettingMutation) 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 SettingMutation) 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 Setting entities.
func (m *SettingMutation) SetID(id uint32) {
	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 *SettingMutation) ID() (id uint32, 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 *SettingMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Setting.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 *SettingMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *SettingMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *SettingMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *SettingMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *SettingMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *SettingMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *SettingMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *SettingMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *SettingMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *SettingMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *SettingMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[setting.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *SettingMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[setting.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *SettingMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, setting.FieldCoinTypeID)
}

// SetFeeCoinTypeID sets the "fee_coin_type_id" field.
func (m *SettingMutation) SetFeeCoinTypeID(u uuid.UUID) {
	m.fee_coin_type_id = &u
}

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

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

// ClearFeeCoinTypeID clears the value of the "fee_coin_type_id" field.
func (m *SettingMutation) ClearFeeCoinTypeID() {
	m.fee_coin_type_id = nil
	m.clearedFields[setting.FieldFeeCoinTypeID] = struct{}{}
}

// FeeCoinTypeIDCleared returns if the "fee_coin_type_id" field was cleared in this mutation.
func (m *SettingMutation) FeeCoinTypeIDCleared() bool {
	_, ok := m.clearedFields[setting.FieldFeeCoinTypeID]
	return ok
}

// ResetFeeCoinTypeID resets all changes to the "fee_coin_type_id" field.
func (m *SettingMutation) ResetFeeCoinTypeID() {
	m.fee_coin_type_id = nil
	delete(m.clearedFields, setting.FieldFeeCoinTypeID)
}

// SetWithdrawFeeByStableUsd sets the "withdraw_fee_by_stable_usd" field.
func (m *SettingMutation) SetWithdrawFeeByStableUsd(b bool) {
	m.withdraw_fee_by_stable_usd = &b
}

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

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

// ClearWithdrawFeeByStableUsd clears the value of the "withdraw_fee_by_stable_usd" field.
func (m *SettingMutation) ClearWithdrawFeeByStableUsd() {
	m.withdraw_fee_by_stable_usd = nil
	m.clearedFields[setting.FieldWithdrawFeeByStableUsd] = struct{}{}
}

// WithdrawFeeByStableUsdCleared returns if the "withdraw_fee_by_stable_usd" field was cleared in this mutation.
func (m *SettingMutation) WithdrawFeeByStableUsdCleared() bool {
	_, ok := m.clearedFields[setting.FieldWithdrawFeeByStableUsd]
	return ok
}

// ResetWithdrawFeeByStableUsd resets all changes to the "withdraw_fee_by_stable_usd" field.
func (m *SettingMutation) ResetWithdrawFeeByStableUsd() {
	m.withdraw_fee_by_stable_usd = nil
	delete(m.clearedFields, setting.FieldWithdrawFeeByStableUsd)
}

// SetWithdrawFeeAmount sets the "withdraw_fee_amount" field.
func (m *SettingMutation) SetWithdrawFeeAmount(d decimal.Decimal) {
	m.withdraw_fee_amount = &d
}

// WithdrawFeeAmount returns the value of the "withdraw_fee_amount" field in the mutation.
func (m *SettingMutation) WithdrawFeeAmount() (r decimal.Decimal, exists bool) {
	v := m.withdraw_fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearWithdrawFeeAmount clears the value of the "withdraw_fee_amount" field.
func (m *SettingMutation) ClearWithdrawFeeAmount() {
	m.withdraw_fee_amount = nil
	m.clearedFields[setting.FieldWithdrawFeeAmount] = struct{}{}
}

// WithdrawFeeAmountCleared returns if the "withdraw_fee_amount" field was cleared in this mutation.
func (m *SettingMutation) WithdrawFeeAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldWithdrawFeeAmount]
	return ok
}

// ResetWithdrawFeeAmount resets all changes to the "withdraw_fee_amount" field.
func (m *SettingMutation) ResetWithdrawFeeAmount() {
	m.withdraw_fee_amount = nil
	delete(m.clearedFields, setting.FieldWithdrawFeeAmount)
}

// SetCollectFeeAmount sets the "collect_fee_amount" field.
func (m *SettingMutation) SetCollectFeeAmount(d decimal.Decimal) {
	m.collect_fee_amount = &d
}

// CollectFeeAmount returns the value of the "collect_fee_amount" field in the mutation.
func (m *SettingMutation) CollectFeeAmount() (r decimal.Decimal, exists bool) {
	v := m.collect_fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearCollectFeeAmount clears the value of the "collect_fee_amount" field.
func (m *SettingMutation) ClearCollectFeeAmount() {
	m.collect_fee_amount = nil
	m.clearedFields[setting.FieldCollectFeeAmount] = struct{}{}
}

// CollectFeeAmountCleared returns if the "collect_fee_amount" field was cleared in this mutation.
func (m *SettingMutation) CollectFeeAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldCollectFeeAmount]
	return ok
}

// ResetCollectFeeAmount resets all changes to the "collect_fee_amount" field.
func (m *SettingMutation) ResetCollectFeeAmount() {
	m.collect_fee_amount = nil
	delete(m.clearedFields, setting.FieldCollectFeeAmount)
}

// SetHotWalletFeeAmount sets the "hot_wallet_fee_amount" field.
func (m *SettingMutation) SetHotWalletFeeAmount(d decimal.Decimal) {
	m.hot_wallet_fee_amount = &d
}

// HotWalletFeeAmount returns the value of the "hot_wallet_fee_amount" field in the mutation.
func (m *SettingMutation) HotWalletFeeAmount() (r decimal.Decimal, exists bool) {
	v := m.hot_wallet_fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearHotWalletFeeAmount clears the value of the "hot_wallet_fee_amount" field.
func (m *SettingMutation) ClearHotWalletFeeAmount() {
	m.hot_wallet_fee_amount = nil
	m.clearedFields[setting.FieldHotWalletFeeAmount] = struct{}{}
}

// HotWalletFeeAmountCleared returns if the "hot_wallet_fee_amount" field was cleared in this mutation.
func (m *SettingMutation) HotWalletFeeAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldHotWalletFeeAmount]
	return ok
}

// ResetHotWalletFeeAmount resets all changes to the "hot_wallet_fee_amount" field.
func (m *SettingMutation) ResetHotWalletFeeAmount() {
	m.hot_wallet_fee_amount = nil
	delete(m.clearedFields, setting.FieldHotWalletFeeAmount)
}

// SetLowFeeAmount sets the "low_fee_amount" field.
func (m *SettingMutation) SetLowFeeAmount(d decimal.Decimal) {
	m.low_fee_amount = &d
}

// LowFeeAmount returns the value of the "low_fee_amount" field in the mutation.
func (m *SettingMutation) LowFeeAmount() (r decimal.Decimal, exists bool) {
	v := m.low_fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearLowFeeAmount clears the value of the "low_fee_amount" field.
func (m *SettingMutation) ClearLowFeeAmount() {
	m.low_fee_amount = nil
	m.clearedFields[setting.FieldLowFeeAmount] = struct{}{}
}

// LowFeeAmountCleared returns if the "low_fee_amount" field was cleared in this mutation.
func (m *SettingMutation) LowFeeAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldLowFeeAmount]
	return ok
}

// ResetLowFeeAmount resets all changes to the "low_fee_amount" field.
func (m *SettingMutation) ResetLowFeeAmount() {
	m.low_fee_amount = nil
	delete(m.clearedFields, setting.FieldLowFeeAmount)
}

// SetHotLowFeeAmount sets the "hot_low_fee_amount" field.
func (m *SettingMutation) SetHotLowFeeAmount(d decimal.Decimal) {
	m.hot_low_fee_amount = &d
}

// HotLowFeeAmount returns the value of the "hot_low_fee_amount" field in the mutation.
func (m *SettingMutation) HotLowFeeAmount() (r decimal.Decimal, exists bool) {
	v := m.hot_low_fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearHotLowFeeAmount clears the value of the "hot_low_fee_amount" field.
func (m *SettingMutation) ClearHotLowFeeAmount() {
	m.hot_low_fee_amount = nil
	m.clearedFields[setting.FieldHotLowFeeAmount] = struct{}{}
}

// HotLowFeeAmountCleared returns if the "hot_low_fee_amount" field was cleared in this mutation.
func (m *SettingMutation) HotLowFeeAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldHotLowFeeAmount]
	return ok
}

// ResetHotLowFeeAmount resets all changes to the "hot_low_fee_amount" field.
func (m *SettingMutation) ResetHotLowFeeAmount() {
	m.hot_low_fee_amount = nil
	delete(m.clearedFields, setting.FieldHotLowFeeAmount)
}

// SetHotWalletAccountAmount sets the "hot_wallet_account_amount" field.
func (m *SettingMutation) SetHotWalletAccountAmount(d decimal.Decimal) {
	m.hot_wallet_account_amount = &d
}

// HotWalletAccountAmount returns the value of the "hot_wallet_account_amount" field in the mutation.
func (m *SettingMutation) HotWalletAccountAmount() (r decimal.Decimal, exists bool) {
	v := m.hot_wallet_account_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearHotWalletAccountAmount clears the value of the "hot_wallet_account_amount" field.
func (m *SettingMutation) ClearHotWalletAccountAmount() {
	m.hot_wallet_account_amount = nil
	m.clearedFields[setting.FieldHotWalletAccountAmount] = struct{}{}
}

// HotWalletAccountAmountCleared returns if the "hot_wallet_account_amount" field was cleared in this mutation.
func (m *SettingMutation) HotWalletAccountAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldHotWalletAccountAmount]
	return ok
}

// ResetHotWalletAccountAmount resets all changes to the "hot_wallet_account_amount" field.
func (m *SettingMutation) ResetHotWalletAccountAmount() {
	m.hot_wallet_account_amount = nil
	delete(m.clearedFields, setting.FieldHotWalletAccountAmount)
}

// SetPaymentAccountCollectAmount sets the "payment_account_collect_amount" field.
func (m *SettingMutation) SetPaymentAccountCollectAmount(d decimal.Decimal) {
	m.payment_account_collect_amount = &d
}

// PaymentAccountCollectAmount returns the value of the "payment_account_collect_amount" field in the mutation.
func (m *SettingMutation) PaymentAccountCollectAmount() (r decimal.Decimal, exists bool) {
	v := m.payment_account_collect_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearPaymentAccountCollectAmount clears the value of the "payment_account_collect_amount" field.
func (m *SettingMutation) ClearPaymentAccountCollectAmount() {
	m.payment_account_collect_amount = nil
	m.clearedFields[setting.FieldPaymentAccountCollectAmount] = struct{}{}
}

// PaymentAccountCollectAmountCleared returns if the "payment_account_collect_amount" field was cleared in this mutation.
func (m *SettingMutation) PaymentAccountCollectAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldPaymentAccountCollectAmount]
	return ok
}

// ResetPaymentAccountCollectAmount resets all changes to the "payment_account_collect_amount" field.
func (m *SettingMutation) ResetPaymentAccountCollectAmount() {
	m.payment_account_collect_amount = nil
	delete(m.clearedFields, setting.FieldPaymentAccountCollectAmount)
}

// SetLeastTransferAmount sets the "least_transfer_amount" field.
func (m *SettingMutation) SetLeastTransferAmount(d decimal.Decimal) {
	m.least_transfer_amount = &d
}

// LeastTransferAmount returns the value of the "least_transfer_amount" field in the mutation.
func (m *SettingMutation) LeastTransferAmount() (r decimal.Decimal, exists bool) {
	v := m.least_transfer_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearLeastTransferAmount clears the value of the "least_transfer_amount" field.
func (m *SettingMutation) ClearLeastTransferAmount() {
	m.least_transfer_amount = nil
	m.clearedFields[setting.FieldLeastTransferAmount] = struct{}{}
}

// LeastTransferAmountCleared returns if the "least_transfer_amount" field was cleared in this mutation.
func (m *SettingMutation) LeastTransferAmountCleared() bool {
	_, ok := m.clearedFields[setting.FieldLeastTransferAmount]
	return ok
}

// ResetLeastTransferAmount resets all changes to the "least_transfer_amount" field.
func (m *SettingMutation) ResetLeastTransferAmount() {
	m.least_transfer_amount = nil
	delete(m.clearedFields, setting.FieldLeastTransferAmount)
}

// SetNeedMemo sets the "need_memo" field.
func (m *SettingMutation) SetNeedMemo(b bool) {
	m.need_memo = &b
}

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

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

// ClearNeedMemo clears the value of the "need_memo" field.
func (m *SettingMutation) ClearNeedMemo() {
	m.need_memo = nil
	m.clearedFields[setting.FieldNeedMemo] = struct{}{}
}

// NeedMemoCleared returns if the "need_memo" field was cleared in this mutation.
func (m *SettingMutation) NeedMemoCleared() bool {
	_, ok := m.clearedFields[setting.FieldNeedMemo]
	return ok
}

// ResetNeedMemo resets all changes to the "need_memo" field.
func (m *SettingMutation) ResetNeedMemo() {
	m.need_memo = nil
	delete(m.clearedFields, setting.FieldNeedMemo)
}

// SetRefreshCurrency sets the "refresh_currency" field.
func (m *SettingMutation) SetRefreshCurrency(b bool) {
	m.refresh_currency = &b
}

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

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

// ClearRefreshCurrency clears the value of the "refresh_currency" field.
func (m *SettingMutation) ClearRefreshCurrency() {
	m.refresh_currency = nil
	m.clearedFields[setting.FieldRefreshCurrency] = struct{}{}
}

// RefreshCurrencyCleared returns if the "refresh_currency" field was cleared in this mutation.
func (m *SettingMutation) RefreshCurrencyCleared() bool {
	_, ok := m.clearedFields[setting.FieldRefreshCurrency]
	return ok
}

// ResetRefreshCurrency resets all changes to the "refresh_currency" field.
func (m *SettingMutation) ResetRefreshCurrency() {
	m.refresh_currency = nil
	delete(m.clearedFields, setting.FieldRefreshCurrency)
}

// SetCheckNewAddressBalance sets the "check_new_address_balance" field.
func (m *SettingMutation) SetCheckNewAddressBalance(b bool) {
	m.check_new_address_balance = &b
}

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

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

// ClearCheckNewAddressBalance clears the value of the "check_new_address_balance" field.
func (m *SettingMutation) ClearCheckNewAddressBalance() {
	m.check_new_address_balance = nil
	m.clearedFields[setting.FieldCheckNewAddressBalance] = struct{}{}
}

// CheckNewAddressBalanceCleared returns if the "check_new_address_balance" field was cleared in this mutation.
func (m *SettingMutation) CheckNewAddressBalanceCleared() bool {
	_, ok := m.clearedFields[setting.FieldCheckNewAddressBalance]
	return ok
}

// ResetCheckNewAddressBalance resets all changes to the "check_new_address_balance" field.
func (m *SettingMutation) ResetCheckNewAddressBalance() {
	m.check_new_address_balance = nil
	delete(m.clearedFields, setting.FieldCheckNewAddressBalance)
}

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

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

// Type returns the node type of this mutation (Setting).
func (m *SettingMutation) 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 *SettingMutation) Fields() []string {
	fields := make([]string, 0, 18)
	if m.created_at != nil {
		fields = append(fields, setting.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, setting.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, setting.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, setting.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, setting.FieldCoinTypeID)
	}
	if m.fee_coin_type_id != nil {
		fields = append(fields, setting.FieldFeeCoinTypeID)
	}
	if m.withdraw_fee_by_stable_usd != nil {
		fields = append(fields, setting.FieldWithdrawFeeByStableUsd)
	}
	if m.withdraw_fee_amount != nil {
		fields = append(fields, setting.FieldWithdrawFeeAmount)
	}
	if m.collect_fee_amount != nil {
		fields = append(fields, setting.FieldCollectFeeAmount)
	}
	if m.hot_wallet_fee_amount != nil {
		fields = append(fields, setting.FieldHotWalletFeeAmount)
	}
	if m.low_fee_amount != nil {
		fields = append(fields, setting.FieldLowFeeAmount)
	}
	if m.hot_low_fee_amount != nil {
		fields = append(fields, setting.FieldHotLowFeeAmount)
	}
	if m.hot_wallet_account_amount != nil {
		fields = append(fields, setting.FieldHotWalletAccountAmount)
	}
	if m.payment_account_collect_amount != nil {
		fields = append(fields, setting.FieldPaymentAccountCollectAmount)
	}
	if m.least_transfer_amount != nil {
		fields = append(fields, setting.FieldLeastTransferAmount)
	}
	if m.need_memo != nil {
		fields = append(fields, setting.FieldNeedMemo)
	}
	if m.refresh_currency != nil {
		fields = append(fields, setting.FieldRefreshCurrency)
	}
	if m.check_new_address_balance != nil {
		fields = append(fields, setting.FieldCheckNewAddressBalance)
	}
	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 *SettingMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case setting.FieldCreatedAt:
		return m.CreatedAt()
	case setting.FieldUpdatedAt:
		return m.UpdatedAt()
	case setting.FieldDeletedAt:
		return m.DeletedAt()
	case setting.FieldEntID:
		return m.EntID()
	case setting.FieldCoinTypeID:
		return m.CoinTypeID()
	case setting.FieldFeeCoinTypeID:
		return m.FeeCoinTypeID()
	case setting.FieldWithdrawFeeByStableUsd:
		return m.WithdrawFeeByStableUsd()
	case setting.FieldWithdrawFeeAmount:
		return m.WithdrawFeeAmount()
	case setting.FieldCollectFeeAmount:
		return m.CollectFeeAmount()
	case setting.FieldHotWalletFeeAmount:
		return m.HotWalletFeeAmount()
	case setting.FieldLowFeeAmount:
		return m.LowFeeAmount()
	case setting.FieldHotLowFeeAmount:
		return m.HotLowFeeAmount()
	case setting.FieldHotWalletAccountAmount:
		return m.HotWalletAccountAmount()
	case setting.FieldPaymentAccountCollectAmount:
		return m.PaymentAccountCollectAmount()
	case setting.FieldLeastTransferAmount:
		return m.LeastTransferAmount()
	case setting.FieldNeedMemo:
		return m.NeedMemo()
	case setting.FieldRefreshCurrency:
		return m.RefreshCurrency()
	case setting.FieldCheckNewAddressBalance:
		return m.CheckNewAddressBalance()
	}
	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 *SettingMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case setting.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case setting.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case setting.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case setting.FieldEntID:
		return m.OldEntID(ctx)
	case setting.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case setting.FieldFeeCoinTypeID:
		return m.OldFeeCoinTypeID(ctx)
	case setting.FieldWithdrawFeeByStableUsd:
		return m.OldWithdrawFeeByStableUsd(ctx)
	case setting.FieldWithdrawFeeAmount:
		return m.OldWithdrawFeeAmount(ctx)
	case setting.FieldCollectFeeAmount:
		return m.OldCollectFeeAmount(ctx)
	case setting.FieldHotWalletFeeAmount:
		return m.OldHotWalletFeeAmount(ctx)
	case setting.FieldLowFeeAmount:
		return m.OldLowFeeAmount(ctx)
	case setting.FieldHotLowFeeAmount:
		return m.OldHotLowFeeAmount(ctx)
	case setting.FieldHotWalletAccountAmount:
		return m.OldHotWalletAccountAmount(ctx)
	case setting.FieldPaymentAccountCollectAmount:
		return m.OldPaymentAccountCollectAmount(ctx)
	case setting.FieldLeastTransferAmount:
		return m.OldLeastTransferAmount(ctx)
	case setting.FieldNeedMemo:
		return m.OldNeedMemo(ctx)
	case setting.FieldRefreshCurrency:
		return m.OldRefreshCurrency(ctx)
	case setting.FieldCheckNewAddressBalance:
		return m.OldCheckNewAddressBalance(ctx)
	}
	return nil, fmt.Errorf("unknown Setting 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 *SettingMutation) SetField(name string, value ent.Value) error {
	switch name {
	case setting.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case setting.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case setting.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case setting.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case setting.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case setting.FieldFeeCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeeCoinTypeID(v)
		return nil
	case setting.FieldWithdrawFeeByStableUsd:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWithdrawFeeByStableUsd(v)
		return nil
	case setting.FieldWithdrawFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetWithdrawFeeAmount(v)
		return nil
	case setting.FieldCollectFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCollectFeeAmount(v)
		return nil
	case setting.FieldHotWalletFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHotWalletFeeAmount(v)
		return nil
	case setting.FieldLowFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLowFeeAmount(v)
		return nil
	case setting.FieldHotLowFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHotLowFeeAmount(v)
		return nil
	case setting.FieldHotWalletAccountAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetHotWalletAccountAmount(v)
		return nil
	case setting.FieldPaymentAccountCollectAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPaymentAccountCollectAmount(v)
		return nil
	case setting.FieldLeastTransferAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetLeastTransferAmount(v)
		return nil
	case setting.FieldNeedMemo:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNeedMemo(v)
		return nil
	case setting.FieldRefreshCurrency:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRefreshCurrency(v)
		return nil
	case setting.FieldCheckNewAddressBalance:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCheckNewAddressBalance(v)
		return nil
	}
	return fmt.Errorf("unknown Setting field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *SettingMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, setting.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, setting.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, setting.FieldDeletedAt)
	}
	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 *SettingMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case setting.FieldCreatedAt:
		return m.AddedCreatedAt()
	case setting.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case setting.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *SettingMutation) AddField(name string, value ent.Value) error {
	switch name {
	case setting.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case setting.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case setting.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Setting numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *SettingMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(setting.FieldCoinTypeID) {
		fields = append(fields, setting.FieldCoinTypeID)
	}
	if m.FieldCleared(setting.FieldFeeCoinTypeID) {
		fields = append(fields, setting.FieldFeeCoinTypeID)
	}
	if m.FieldCleared(setting.FieldWithdrawFeeByStableUsd) {
		fields = append(fields, setting.FieldWithdrawFeeByStableUsd)
	}
	if m.FieldCleared(setting.FieldWithdrawFeeAmount) {
		fields = append(fields, setting.FieldWithdrawFeeAmount)
	}
	if m.FieldCleared(setting.FieldCollectFeeAmount) {
		fields = append(fields, setting.FieldCollectFeeAmount)
	}
	if m.FieldCleared(setting.FieldHotWalletFeeAmount) {
		fields = append(fields, setting.FieldHotWalletFeeAmount)
	}
	if m.FieldCleared(setting.FieldLowFeeAmount) {
		fields = append(fields, setting.FieldLowFeeAmount)
	}
	if m.FieldCleared(setting.FieldHotLowFeeAmount) {
		fields = append(fields, setting.FieldHotLowFeeAmount)
	}
	if m.FieldCleared(setting.FieldHotWalletAccountAmount) {
		fields = append(fields, setting.FieldHotWalletAccountAmount)
	}
	if m.FieldCleared(setting.FieldPaymentAccountCollectAmount) {
		fields = append(fields, setting.FieldPaymentAccountCollectAmount)
	}
	if m.FieldCleared(setting.FieldLeastTransferAmount) {
		fields = append(fields, setting.FieldLeastTransferAmount)
	}
	if m.FieldCleared(setting.FieldNeedMemo) {
		fields = append(fields, setting.FieldNeedMemo)
	}
	if m.FieldCleared(setting.FieldRefreshCurrency) {
		fields = append(fields, setting.FieldRefreshCurrency)
	}
	if m.FieldCleared(setting.FieldCheckNewAddressBalance) {
		fields = append(fields, setting.FieldCheckNewAddressBalance)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *SettingMutation) 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 *SettingMutation) ClearField(name string) error {
	switch name {
	case setting.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case setting.FieldFeeCoinTypeID:
		m.ClearFeeCoinTypeID()
		return nil
	case setting.FieldWithdrawFeeByStableUsd:
		m.ClearWithdrawFeeByStableUsd()
		return nil
	case setting.FieldWithdrawFeeAmount:
		m.ClearWithdrawFeeAmount()
		return nil
	case setting.FieldCollectFeeAmount:
		m.ClearCollectFeeAmount()
		return nil
	case setting.FieldHotWalletFeeAmount:
		m.ClearHotWalletFeeAmount()
		return nil
	case setting.FieldLowFeeAmount:
		m.ClearLowFeeAmount()
		return nil
	case setting.FieldHotLowFeeAmount:
		m.ClearHotLowFeeAmount()
		return nil
	case setting.FieldHotWalletAccountAmount:
		m.ClearHotWalletAccountAmount()
		return nil
	case setting.FieldPaymentAccountCollectAmount:
		m.ClearPaymentAccountCollectAmount()
		return nil
	case setting.FieldLeastTransferAmount:
		m.ClearLeastTransferAmount()
		return nil
	case setting.FieldNeedMemo:
		m.ClearNeedMemo()
		return nil
	case setting.FieldRefreshCurrency:
		m.ClearRefreshCurrency()
		return nil
	case setting.FieldCheckNewAddressBalance:
		m.ClearCheckNewAddressBalance()
		return nil
	}
	return fmt.Errorf("unknown Setting 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 *SettingMutation) ResetField(name string) error {
	switch name {
	case setting.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case setting.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case setting.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case setting.FieldEntID:
		m.ResetEntID()
		return nil
	case setting.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case setting.FieldFeeCoinTypeID:
		m.ResetFeeCoinTypeID()
		return nil
	case setting.FieldWithdrawFeeByStableUsd:
		m.ResetWithdrawFeeByStableUsd()
		return nil
	case setting.FieldWithdrawFeeAmount:
		m.ResetWithdrawFeeAmount()
		return nil
	case setting.FieldCollectFeeAmount:
		m.ResetCollectFeeAmount()
		return nil
	case setting.FieldHotWalletFeeAmount:
		m.ResetHotWalletFeeAmount()
		return nil
	case setting.FieldLowFeeAmount:
		m.ResetLowFeeAmount()
		return nil
	case setting.FieldHotLowFeeAmount:
		m.ResetHotLowFeeAmount()
		return nil
	case setting.FieldHotWalletAccountAmount:
		m.ResetHotWalletAccountAmount()
		return nil
	case setting.FieldPaymentAccountCollectAmount:
		m.ResetPaymentAccountCollectAmount()
		return nil
	case setting.FieldLeastTransferAmount:
		m.ResetLeastTransferAmount()
		return nil
	case setting.FieldNeedMemo:
		m.ResetNeedMemo()
		return nil
	case setting.FieldRefreshCurrency:
		m.ResetRefreshCurrency()
		return nil
	case setting.FieldCheckNewAddressBalance:
		m.ResetCheckNewAddressBalance()
		return nil
	}
	return fmt.Errorf("unknown Setting field %s", name)
}

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

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

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

// TranMutation represents an operation that mutates the Tran nodes in the graph.
type TranMutation struct {
	config
	op              Op
	typ             string
	id              *uint32
	created_at      *uint32
	addcreated_at   *int32
	updated_at      *uint32
	addupdated_at   *int32
	deleted_at      *uint32
	adddeleted_at   *int32
	ent_id          *uuid.UUID
	coin_type_id    *uuid.UUID
	from_account_id *uuid.UUID
	to_account_id   *uuid.UUID
	amount          *decimal.Decimal
	fee_amount      *decimal.Decimal
	chain_tx_id     *string
	state           *string
	extra           *string
	_type           *string
	clearedFields   map[string]struct{}
	done            bool
	oldValue        func(context.Context) (*Tran, error)
	predicates      []predicate.Tran
}

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

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

// newTranMutation creates new mutation for the Tran entity.
func newTranMutation(c config, op Op, opts ...tranOption) *TranMutation {
	m := &TranMutation{
		config:        c,
		op:            op,
		typ:           TypeTran,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withTran sets the old Tran of the mutation.
func withTran(node *Tran) tranOption {
	return func(m *TranMutation) {
		m.oldValue = func(context.Context) (*Tran, 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 TranMutation) 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 TranMutation) 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 Tran entities.
func (m *TranMutation) SetID(id uint32) {
	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 *TranMutation) ID() (id uint32, 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 *TranMutation) IDs(ctx context.Context) ([]uint32, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uint32{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Tran.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 *TranMutation) SetCreatedAt(u uint32) {
	m.created_at = &u
	m.addcreated_at = nil
}

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

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

// AddCreatedAt adds u to the "created_at" field.
func (m *TranMutation) AddCreatedAt(u int32) {
	if m.addcreated_at != nil {
		*m.addcreated_at += u
	} else {
		m.addcreated_at = &u
	}
}

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

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

// SetUpdatedAt sets the "updated_at" field.
func (m *TranMutation) SetUpdatedAt(u uint32) {
	m.updated_at = &u
	m.addupdated_at = nil
}

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

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

// AddUpdatedAt adds u to the "updated_at" field.
func (m *TranMutation) AddUpdatedAt(u int32) {
	if m.addupdated_at != nil {
		*m.addupdated_at += u
	} else {
		m.addupdated_at = &u
	}
}

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

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

// SetDeletedAt sets the "deleted_at" field.
func (m *TranMutation) SetDeletedAt(u uint32) {
	m.deleted_at = &u
	m.adddeleted_at = nil
}

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

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

// AddDeletedAt adds u to the "deleted_at" field.
func (m *TranMutation) AddDeletedAt(u int32) {
	if m.adddeleted_at != nil {
		*m.adddeleted_at += u
	} else {
		m.adddeleted_at = &u
	}
}

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

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *TranMutation) ResetDeletedAt() {
	m.deleted_at = nil
	m.adddeleted_at = nil
}

// SetEntID sets the "ent_id" field.
func (m *TranMutation) SetEntID(u uuid.UUID) {
	m.ent_id = &u
}

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

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

// ResetEntID resets all changes to the "ent_id" field.
func (m *TranMutation) ResetEntID() {
	m.ent_id = nil
}

// SetCoinTypeID sets the "coin_type_id" field.
func (m *TranMutation) SetCoinTypeID(u uuid.UUID) {
	m.coin_type_id = &u
}

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

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

// ClearCoinTypeID clears the value of the "coin_type_id" field.
func (m *TranMutation) ClearCoinTypeID() {
	m.coin_type_id = nil
	m.clearedFields[tran.FieldCoinTypeID] = struct{}{}
}

// CoinTypeIDCleared returns if the "coin_type_id" field was cleared in this mutation.
func (m *TranMutation) CoinTypeIDCleared() bool {
	_, ok := m.clearedFields[tran.FieldCoinTypeID]
	return ok
}

// ResetCoinTypeID resets all changes to the "coin_type_id" field.
func (m *TranMutation) ResetCoinTypeID() {
	m.coin_type_id = nil
	delete(m.clearedFields, tran.FieldCoinTypeID)
}

// SetFromAccountID sets the "from_account_id" field.
func (m *TranMutation) SetFromAccountID(u uuid.UUID) {
	m.from_account_id = &u
}

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

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

// ClearFromAccountID clears the value of the "from_account_id" field.
func (m *TranMutation) ClearFromAccountID() {
	m.from_account_id = nil
	m.clearedFields[tran.FieldFromAccountID] = struct{}{}
}

// FromAccountIDCleared returns if the "from_account_id" field was cleared in this mutation.
func (m *TranMutation) FromAccountIDCleared() bool {
	_, ok := m.clearedFields[tran.FieldFromAccountID]
	return ok
}

// ResetFromAccountID resets all changes to the "from_account_id" field.
func (m *TranMutation) ResetFromAccountID() {
	m.from_account_id = nil
	delete(m.clearedFields, tran.FieldFromAccountID)
}

// SetToAccountID sets the "to_account_id" field.
func (m *TranMutation) SetToAccountID(u uuid.UUID) {
	m.to_account_id = &u
}

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

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

// ClearToAccountID clears the value of the "to_account_id" field.
func (m *TranMutation) ClearToAccountID() {
	m.to_account_id = nil
	m.clearedFields[tran.FieldToAccountID] = struct{}{}
}

// ToAccountIDCleared returns if the "to_account_id" field was cleared in this mutation.
func (m *TranMutation) ToAccountIDCleared() bool {
	_, ok := m.clearedFields[tran.FieldToAccountID]
	return ok
}

// ResetToAccountID resets all changes to the "to_account_id" field.
func (m *TranMutation) ResetToAccountID() {
	m.to_account_id = nil
	delete(m.clearedFields, tran.FieldToAccountID)
}

// SetAmount sets the "amount" field.
func (m *TranMutation) SetAmount(d decimal.Decimal) {
	m.amount = &d
}

// Amount returns the value of the "amount" field in the mutation.
func (m *TranMutation) Amount() (r decimal.Decimal, exists bool) {
	v := m.amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearAmount clears the value of the "amount" field.
func (m *TranMutation) ClearAmount() {
	m.amount = nil
	m.clearedFields[tran.FieldAmount] = struct{}{}
}

// AmountCleared returns if the "amount" field was cleared in this mutation.
func (m *TranMutation) AmountCleared() bool {
	_, ok := m.clearedFields[tran.FieldAmount]
	return ok
}

// ResetAmount resets all changes to the "amount" field.
func (m *TranMutation) ResetAmount() {
	m.amount = nil
	delete(m.clearedFields, tran.FieldAmount)
}

// SetFeeAmount sets the "fee_amount" field.
func (m *TranMutation) SetFeeAmount(d decimal.Decimal) {
	m.fee_amount = &d
}

// FeeAmount returns the value of the "fee_amount" field in the mutation.
func (m *TranMutation) FeeAmount() (r decimal.Decimal, exists bool) {
	v := m.fee_amount
	if v == nil {
		return
	}
	return *v, true
}

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

// ClearFeeAmount clears the value of the "fee_amount" field.
func (m *TranMutation) ClearFeeAmount() {
	m.fee_amount = nil
	m.clearedFields[tran.FieldFeeAmount] = struct{}{}
}

// FeeAmountCleared returns if the "fee_amount" field was cleared in this mutation.
func (m *TranMutation) FeeAmountCleared() bool {
	_, ok := m.clearedFields[tran.FieldFeeAmount]
	return ok
}

// ResetFeeAmount resets all changes to the "fee_amount" field.
func (m *TranMutation) ResetFeeAmount() {
	m.fee_amount = nil
	delete(m.clearedFields, tran.FieldFeeAmount)
}

// SetChainTxID sets the "chain_tx_id" field.
func (m *TranMutation) SetChainTxID(s string) {
	m.chain_tx_id = &s
}

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

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

// ClearChainTxID clears the value of the "chain_tx_id" field.
func (m *TranMutation) ClearChainTxID() {
	m.chain_tx_id = nil
	m.clearedFields[tran.FieldChainTxID] = struct{}{}
}

// ChainTxIDCleared returns if the "chain_tx_id" field was cleared in this mutation.
func (m *TranMutation) ChainTxIDCleared() bool {
	_, ok := m.clearedFields[tran.FieldChainTxID]
	return ok
}

// ResetChainTxID resets all changes to the "chain_tx_id" field.
func (m *TranMutation) ResetChainTxID() {
	m.chain_tx_id = nil
	delete(m.clearedFields, tran.FieldChainTxID)
}

// SetState sets the "state" field.
func (m *TranMutation) SetState(s string) {
	m.state = &s
}

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

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

// ClearState clears the value of the "state" field.
func (m *TranMutation) ClearState() {
	m.state = nil
	m.clearedFields[tran.FieldState] = struct{}{}
}

// StateCleared returns if the "state" field was cleared in this mutation.
func (m *TranMutation) StateCleared() bool {
	_, ok := m.clearedFields[tran.FieldState]
	return ok
}

// ResetState resets all changes to the "state" field.
func (m *TranMutation) ResetState() {
	m.state = nil
	delete(m.clearedFields, tran.FieldState)
}

// SetExtra sets the "extra" field.
func (m *TranMutation) SetExtra(s string) {
	m.extra = &s
}

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

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

// ClearExtra clears the value of the "extra" field.
func (m *TranMutation) ClearExtra() {
	m.extra = nil
	m.clearedFields[tran.FieldExtra] = struct{}{}
}

// ExtraCleared returns if the "extra" field was cleared in this mutation.
func (m *TranMutation) ExtraCleared() bool {
	_, ok := m.clearedFields[tran.FieldExtra]
	return ok
}

// ResetExtra resets all changes to the "extra" field.
func (m *TranMutation) ResetExtra() {
	m.extra = nil
	delete(m.clearedFields, tran.FieldExtra)
}

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

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

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

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

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

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

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

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

// Type returns the node type of this mutation (Tran).
func (m *TranMutation) 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 *TranMutation) Fields() []string {
	fields := make([]string, 0, 13)
	if m.created_at != nil {
		fields = append(fields, tran.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, tran.FieldUpdatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, tran.FieldDeletedAt)
	}
	if m.ent_id != nil {
		fields = append(fields, tran.FieldEntID)
	}
	if m.coin_type_id != nil {
		fields = append(fields, tran.FieldCoinTypeID)
	}
	if m.from_account_id != nil {
		fields = append(fields, tran.FieldFromAccountID)
	}
	if m.to_account_id != nil {
		fields = append(fields, tran.FieldToAccountID)
	}
	if m.amount != nil {
		fields = append(fields, tran.FieldAmount)
	}
	if m.fee_amount != nil {
		fields = append(fields, tran.FieldFeeAmount)
	}
	if m.chain_tx_id != nil {
		fields = append(fields, tran.FieldChainTxID)
	}
	if m.state != nil {
		fields = append(fields, tran.FieldState)
	}
	if m.extra != nil {
		fields = append(fields, tran.FieldExtra)
	}
	if m._type != nil {
		fields = append(fields, tran.FieldType)
	}
	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 *TranMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case tran.FieldCreatedAt:
		return m.CreatedAt()
	case tran.FieldUpdatedAt:
		return m.UpdatedAt()
	case tran.FieldDeletedAt:
		return m.DeletedAt()
	case tran.FieldEntID:
		return m.EntID()
	case tran.FieldCoinTypeID:
		return m.CoinTypeID()
	case tran.FieldFromAccountID:
		return m.FromAccountID()
	case tran.FieldToAccountID:
		return m.ToAccountID()
	case tran.FieldAmount:
		return m.Amount()
	case tran.FieldFeeAmount:
		return m.FeeAmount()
	case tran.FieldChainTxID:
		return m.ChainTxID()
	case tran.FieldState:
		return m.State()
	case tran.FieldExtra:
		return m.Extra()
	case tran.FieldType:
		return m.GetType()
	}
	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 *TranMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case tran.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case tran.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	case tran.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	case tran.FieldEntID:
		return m.OldEntID(ctx)
	case tran.FieldCoinTypeID:
		return m.OldCoinTypeID(ctx)
	case tran.FieldFromAccountID:
		return m.OldFromAccountID(ctx)
	case tran.FieldToAccountID:
		return m.OldToAccountID(ctx)
	case tran.FieldAmount:
		return m.OldAmount(ctx)
	case tran.FieldFeeAmount:
		return m.OldFeeAmount(ctx)
	case tran.FieldChainTxID:
		return m.OldChainTxID(ctx)
	case tran.FieldState:
		return m.OldState(ctx)
	case tran.FieldExtra:
		return m.OldExtra(ctx)
	case tran.FieldType:
		return m.OldType(ctx)
	}
	return nil, fmt.Errorf("unknown Tran 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 *TranMutation) SetField(name string, value ent.Value) error {
	switch name {
	case tran.FieldCreatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case tran.FieldUpdatedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	case tran.FieldDeletedAt:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	case tran.FieldEntID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEntID(v)
		return nil
	case tran.FieldCoinTypeID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCoinTypeID(v)
		return nil
	case tran.FieldFromAccountID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFromAccountID(v)
		return nil
	case tran.FieldToAccountID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetToAccountID(v)
		return nil
	case tran.FieldAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAmount(v)
		return nil
	case tran.FieldFeeAmount:
		v, ok := value.(decimal.Decimal)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFeeAmount(v)
		return nil
	case tran.FieldChainTxID:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetChainTxID(v)
		return nil
	case tran.FieldState:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetState(v)
		return nil
	case tran.FieldExtra:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetExtra(v)
		return nil
	case tran.FieldType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetType(v)
		return nil
	}
	return fmt.Errorf("unknown Tran field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *TranMutation) AddedFields() []string {
	var fields []string
	if m.addcreated_at != nil {
		fields = append(fields, tran.FieldCreatedAt)
	}
	if m.addupdated_at != nil {
		fields = append(fields, tran.FieldUpdatedAt)
	}
	if m.adddeleted_at != nil {
		fields = append(fields, tran.FieldDeletedAt)
	}
	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 *TranMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case tran.FieldCreatedAt:
		return m.AddedCreatedAt()
	case tran.FieldUpdatedAt:
		return m.AddedUpdatedAt()
	case tran.FieldDeletedAt:
		return m.AddedDeletedAt()
	}
	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 *TranMutation) AddField(name string, value ent.Value) error {
	switch name {
	case tran.FieldCreatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddCreatedAt(v)
		return nil
	case tran.FieldUpdatedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUpdatedAt(v)
		return nil
	case tran.FieldDeletedAt:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Tran numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *TranMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(tran.FieldCoinTypeID) {
		fields = append(fields, tran.FieldCoinTypeID)
	}
	if m.FieldCleared(tran.FieldFromAccountID) {
		fields = append(fields, tran.FieldFromAccountID)
	}
	if m.FieldCleared(tran.FieldToAccountID) {
		fields = append(fields, tran.FieldToAccountID)
	}
	if m.FieldCleared(tran.FieldAmount) {
		fields = append(fields, tran.FieldAmount)
	}
	if m.FieldCleared(tran.FieldFeeAmount) {
		fields = append(fields, tran.FieldFeeAmount)
	}
	if m.FieldCleared(tran.FieldChainTxID) {
		fields = append(fields, tran.FieldChainTxID)
	}
	if m.FieldCleared(tran.FieldState) {
		fields = append(fields, tran.FieldState)
	}
	if m.FieldCleared(tran.FieldExtra) {
		fields = append(fields, tran.FieldExtra)
	}
	if m.FieldCleared(tran.FieldType) {
		fields = append(fields, tran.FieldType)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *TranMutation) 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 *TranMutation) ClearField(name string) error {
	switch name {
	case tran.FieldCoinTypeID:
		m.ClearCoinTypeID()
		return nil
	case tran.FieldFromAccountID:
		m.ClearFromAccountID()
		return nil
	case tran.FieldToAccountID:
		m.ClearToAccountID()
		return nil
	case tran.FieldAmount:
		m.ClearAmount()
		return nil
	case tran.FieldFeeAmount:
		m.ClearFeeAmount()
		return nil
	case tran.FieldChainTxID:
		m.ClearChainTxID()
		return nil
	case tran.FieldState:
		m.ClearState()
		return nil
	case tran.FieldExtra:
		m.ClearExtra()
		return nil
	case tran.FieldType:
		m.ClearType()
		return nil
	}
	return fmt.Errorf("unknown Tran 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 *TranMutation) ResetField(name string) error {
	switch name {
	case tran.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case tran.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	case tran.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	case tran.FieldEntID:
		m.ResetEntID()
		return nil
	case tran.FieldCoinTypeID:
		m.ResetCoinTypeID()
		return nil
	case tran.FieldFromAccountID:
		m.ResetFromAccountID()
		return nil
	case tran.FieldToAccountID:
		m.ResetToAccountID()
		return nil
	case tran.FieldAmount:
		m.ResetAmount()
		return nil
	case tran.FieldFeeAmount:
		m.ResetFeeAmount()
		return nil
	case tran.FieldChainTxID:
		m.ResetChainTxID()
		return nil
	case tran.FieldState:
		m.ResetState()
		return nil
	case tran.FieldExtra:
		m.ResetExtra()
		return nil
	case tran.FieldType:
		m.ResetType()
		return nil
	}
	return fmt.Errorf("unknown Tran field %s", name)
}

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

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

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