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

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/migrate"

	"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/setting"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/tran"

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

// Client is the client that holds all ent builders.
type Client struct {
	config
	// Schema is the client for creating, migrating and dropping schema.
	Schema *migrate.Schema
	// AppCoin is the client for interacting with the AppCoin builders.
	AppCoin *AppCoinClient
	// ChainBase is the client for interacting with the ChainBase builders.
	ChainBase *ChainBaseClient
	// CoinBase is the client for interacting with the CoinBase builders.
	CoinBase *CoinBaseClient
	// CoinDescription is the client for interacting with the CoinDescription builders.
	CoinDescription *CoinDescriptionClient
	// CoinExtra is the client for interacting with the CoinExtra builders.
	CoinExtra *CoinExtraClient
	// CoinFiat is the client for interacting with the CoinFiat builders.
	CoinFiat *CoinFiatClient
	// CoinFiatCurrency is the client for interacting with the CoinFiatCurrency builders.
	CoinFiatCurrency *CoinFiatCurrencyClient
	// CoinFiatCurrencyHistory is the client for interacting with the CoinFiatCurrencyHistory builders.
	CoinFiatCurrencyHistory *CoinFiatCurrencyHistoryClient
	// CoinUsedFor is the client for interacting with the CoinUsedFor builders.
	CoinUsedFor *CoinUsedForClient
	// Currency is the client for interacting with the Currency builders.
	Currency *CurrencyClient
	// CurrencyFeed is the client for interacting with the CurrencyFeed builders.
	CurrencyFeed *CurrencyFeedClient
	// CurrencyHistory is the client for interacting with the CurrencyHistory builders.
	CurrencyHistory *CurrencyHistoryClient
	// ExchangeRate is the client for interacting with the ExchangeRate builders.
	ExchangeRate *ExchangeRateClient
	// Fiat is the client for interacting with the Fiat builders.
	Fiat *FiatClient
	// FiatCurrency is the client for interacting with the FiatCurrency builders.
	FiatCurrency *FiatCurrencyClient
	// FiatCurrencyFeed is the client for interacting with the FiatCurrencyFeed builders.
	FiatCurrencyFeed *FiatCurrencyFeedClient
	// FiatCurrencyHistory is the client for interacting with the FiatCurrencyHistory builders.
	FiatCurrencyHistory *FiatCurrencyHistoryClient
	// Setting is the client for interacting with the Setting builders.
	Setting *SettingClient
	// Tran is the client for interacting with the Tran builders.
	Tran *TranClient
}

// NewClient creates a new client configured with the given options.
func NewClient(opts ...Option) *Client {
	cfg := config{log: log.Println, hooks: &hooks{}}
	cfg.options(opts...)
	client := &Client{config: cfg}
	client.init()
	return client
}

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.AppCoin = NewAppCoinClient(c.config)
	c.ChainBase = NewChainBaseClient(c.config)
	c.CoinBase = NewCoinBaseClient(c.config)
	c.CoinDescription = NewCoinDescriptionClient(c.config)
	c.CoinExtra = NewCoinExtraClient(c.config)
	c.CoinFiat = NewCoinFiatClient(c.config)
	c.CoinFiatCurrency = NewCoinFiatCurrencyClient(c.config)
	c.CoinFiatCurrencyHistory = NewCoinFiatCurrencyHistoryClient(c.config)
	c.CoinUsedFor = NewCoinUsedForClient(c.config)
	c.Currency = NewCurrencyClient(c.config)
	c.CurrencyFeed = NewCurrencyFeedClient(c.config)
	c.CurrencyHistory = NewCurrencyHistoryClient(c.config)
	c.ExchangeRate = NewExchangeRateClient(c.config)
	c.Fiat = NewFiatClient(c.config)
	c.FiatCurrency = NewFiatCurrencyClient(c.config)
	c.FiatCurrencyFeed = NewFiatCurrencyFeedClient(c.config)
	c.FiatCurrencyHistory = NewFiatCurrencyHistoryClient(c.config)
	c.Setting = NewSettingClient(c.config)
	c.Tran = NewTranClient(c.config)
}

// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
	switch driverName {
	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
		drv, err := sql.Open(driverName, dataSourceName)
		if err != nil {
			return nil, err
		}
		return NewClient(append(options, Driver(drv))...), nil
	default:
		return nil, fmt.Errorf("unsupported driver: %q", driverName)
	}
}

// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := newTx(ctx, c.driver)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:                     ctx,
		config:                  cfg,
		AppCoin:                 NewAppCoinClient(cfg),
		ChainBase:               NewChainBaseClient(cfg),
		CoinBase:                NewCoinBaseClient(cfg),
		CoinDescription:         NewCoinDescriptionClient(cfg),
		CoinExtra:               NewCoinExtraClient(cfg),
		CoinFiat:                NewCoinFiatClient(cfg),
		CoinFiatCurrency:        NewCoinFiatCurrencyClient(cfg),
		CoinFiatCurrencyHistory: NewCoinFiatCurrencyHistoryClient(cfg),
		CoinUsedFor:             NewCoinUsedForClient(cfg),
		Currency:                NewCurrencyClient(cfg),
		CurrencyFeed:            NewCurrencyFeedClient(cfg),
		CurrencyHistory:         NewCurrencyHistoryClient(cfg),
		ExchangeRate:            NewExchangeRateClient(cfg),
		Fiat:                    NewFiatClient(cfg),
		FiatCurrency:            NewFiatCurrencyClient(cfg),
		FiatCurrencyFeed:        NewFiatCurrencyFeedClient(cfg),
		FiatCurrencyHistory:     NewFiatCurrencyHistoryClient(cfg),
		Setting:                 NewSettingClient(cfg),
		Tran:                    NewTranClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := c.driver.(interface {
		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
	}).BeginTx(ctx, opts)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = &txDriver{tx: tx, drv: c.driver}
	return &Tx{
		ctx:                     ctx,
		config:                  cfg,
		AppCoin:                 NewAppCoinClient(cfg),
		ChainBase:               NewChainBaseClient(cfg),
		CoinBase:                NewCoinBaseClient(cfg),
		CoinDescription:         NewCoinDescriptionClient(cfg),
		CoinExtra:               NewCoinExtraClient(cfg),
		CoinFiat:                NewCoinFiatClient(cfg),
		CoinFiatCurrency:        NewCoinFiatCurrencyClient(cfg),
		CoinFiatCurrencyHistory: NewCoinFiatCurrencyHistoryClient(cfg),
		CoinUsedFor:             NewCoinUsedForClient(cfg),
		Currency:                NewCurrencyClient(cfg),
		CurrencyFeed:            NewCurrencyFeedClient(cfg),
		CurrencyHistory:         NewCurrencyHistoryClient(cfg),
		ExchangeRate:            NewExchangeRateClient(cfg),
		Fiat:                    NewFiatClient(cfg),
		FiatCurrency:            NewFiatCurrencyClient(cfg),
		FiatCurrencyFeed:        NewFiatCurrencyFeedClient(cfg),
		FiatCurrencyHistory:     NewFiatCurrencyHistoryClient(cfg),
		Setting:                 NewSettingClient(cfg),
		Tran:                    NewTranClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		AppCoin.
//		Query().
//		Count(ctx)
//
func (c *Client) Debug() *Client {
	if c.debug {
		return c
	}
	cfg := c.config
	cfg.driver = dialect.Debug(c.driver, c.log)
	client := &Client{config: cfg}
	client.init()
	return client
}

// Close closes the database connection and prevents new queries from starting.
func (c *Client) Close() error {
	return c.driver.Close()
}

// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
	c.AppCoin.Use(hooks...)
	c.ChainBase.Use(hooks...)
	c.CoinBase.Use(hooks...)
	c.CoinDescription.Use(hooks...)
	c.CoinExtra.Use(hooks...)
	c.CoinFiat.Use(hooks...)
	c.CoinFiatCurrency.Use(hooks...)
	c.CoinFiatCurrencyHistory.Use(hooks...)
	c.CoinUsedFor.Use(hooks...)
	c.Currency.Use(hooks...)
	c.CurrencyFeed.Use(hooks...)
	c.CurrencyHistory.Use(hooks...)
	c.ExchangeRate.Use(hooks...)
	c.Fiat.Use(hooks...)
	c.FiatCurrency.Use(hooks...)
	c.FiatCurrencyFeed.Use(hooks...)
	c.FiatCurrencyHistory.Use(hooks...)
	c.Setting.Use(hooks...)
	c.Tran.Use(hooks...)
}

// AppCoinClient is a client for the AppCoin schema.
type AppCoinClient struct {
	config
}

// NewAppCoinClient returns a client for the AppCoin from the given config.
func NewAppCoinClient(c config) *AppCoinClient {
	return &AppCoinClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `appcoin.Hooks(f(g(h())))`.
func (c *AppCoinClient) Use(hooks ...Hook) {
	c.hooks.AppCoin = append(c.hooks.AppCoin, hooks...)
}

// Create returns a builder for creating a AppCoin entity.
func (c *AppCoinClient) Create() *AppCoinCreate {
	mutation := newAppCoinMutation(c.config, OpCreate)
	return &AppCoinCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppCoin entities.
func (c *AppCoinClient) CreateBulk(builders ...*AppCoinCreate) *AppCoinCreateBulk {
	return &AppCoinCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppCoin.
func (c *AppCoinClient) Update() *AppCoinUpdate {
	mutation := newAppCoinMutation(c.config, OpUpdate)
	return &AppCoinUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppCoinClient) UpdateOne(ac *AppCoin) *AppCoinUpdateOne {
	mutation := newAppCoinMutation(c.config, OpUpdateOne, withAppCoin(ac))
	return &AppCoinUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppCoinClient) UpdateOneID(id uint32) *AppCoinUpdateOne {
	mutation := newAppCoinMutation(c.config, OpUpdateOne, withAppCoinID(id))
	return &AppCoinUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppCoin.
func (c *AppCoinClient) Delete() *AppCoinDelete {
	mutation := newAppCoinMutation(c.config, OpDelete)
	return &AppCoinDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppCoinClient) DeleteOne(ac *AppCoin) *AppCoinDeleteOne {
	return c.DeleteOneID(ac.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *AppCoinClient) DeleteOneID(id uint32) *AppCoinDeleteOne {
	builder := c.Delete().Where(appcoin.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &AppCoinDeleteOne{builder}
}

// Query returns a query builder for AppCoin.
func (c *AppCoinClient) Query() *AppCoinQuery {
	return &AppCoinQuery{
		config: c.config,
	}
}

// Get returns a AppCoin entity by its id.
func (c *AppCoinClient) Get(ctx context.Context, id uint32) (*AppCoin, error) {
	return c.Query().Where(appcoin.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *AppCoinClient) GetX(ctx context.Context, id uint32) *AppCoin {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *AppCoinClient) Hooks() []Hook {
	hooks := c.hooks.AppCoin
	return append(hooks[:len(hooks):len(hooks)], appcoin.Hooks[:]...)
}

// ChainBaseClient is a client for the ChainBase schema.
type ChainBaseClient struct {
	config
}

// NewChainBaseClient returns a client for the ChainBase from the given config.
func NewChainBaseClient(c config) *ChainBaseClient {
	return &ChainBaseClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `chainbase.Hooks(f(g(h())))`.
func (c *ChainBaseClient) Use(hooks ...Hook) {
	c.hooks.ChainBase = append(c.hooks.ChainBase, hooks...)
}

// Create returns a builder for creating a ChainBase entity.
func (c *ChainBaseClient) Create() *ChainBaseCreate {
	mutation := newChainBaseMutation(c.config, OpCreate)
	return &ChainBaseCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ChainBase entities.
func (c *ChainBaseClient) CreateBulk(builders ...*ChainBaseCreate) *ChainBaseCreateBulk {
	return &ChainBaseCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ChainBase.
func (c *ChainBaseClient) Update() *ChainBaseUpdate {
	mutation := newChainBaseMutation(c.config, OpUpdate)
	return &ChainBaseUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ChainBaseClient) UpdateOne(cb *ChainBase) *ChainBaseUpdateOne {
	mutation := newChainBaseMutation(c.config, OpUpdateOne, withChainBase(cb))
	return &ChainBaseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ChainBaseClient) UpdateOneID(id uint32) *ChainBaseUpdateOne {
	mutation := newChainBaseMutation(c.config, OpUpdateOne, withChainBaseID(id))
	return &ChainBaseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ChainBase.
func (c *ChainBaseClient) Delete() *ChainBaseDelete {
	mutation := newChainBaseMutation(c.config, OpDelete)
	return &ChainBaseDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ChainBaseClient) DeleteOne(cb *ChainBase) *ChainBaseDeleteOne {
	return c.DeleteOneID(cb.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ChainBaseClient) DeleteOneID(id uint32) *ChainBaseDeleteOne {
	builder := c.Delete().Where(chainbase.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ChainBaseDeleteOne{builder}
}

// Query returns a query builder for ChainBase.
func (c *ChainBaseClient) Query() *ChainBaseQuery {
	return &ChainBaseQuery{
		config: c.config,
	}
}

// Get returns a ChainBase entity by its id.
func (c *ChainBaseClient) Get(ctx context.Context, id uint32) (*ChainBase, error) {
	return c.Query().Where(chainbase.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ChainBaseClient) GetX(ctx context.Context, id uint32) *ChainBase {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *ChainBaseClient) Hooks() []Hook {
	hooks := c.hooks.ChainBase
	return append(hooks[:len(hooks):len(hooks)], chainbase.Hooks[:]...)
}

// CoinBaseClient is a client for the CoinBase schema.
type CoinBaseClient struct {
	config
}

// NewCoinBaseClient returns a client for the CoinBase from the given config.
func NewCoinBaseClient(c config) *CoinBaseClient {
	return &CoinBaseClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinbase.Hooks(f(g(h())))`.
func (c *CoinBaseClient) Use(hooks ...Hook) {
	c.hooks.CoinBase = append(c.hooks.CoinBase, hooks...)
}

// Create returns a builder for creating a CoinBase entity.
func (c *CoinBaseClient) Create() *CoinBaseCreate {
	mutation := newCoinBaseMutation(c.config, OpCreate)
	return &CoinBaseCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinBase entities.
func (c *CoinBaseClient) CreateBulk(builders ...*CoinBaseCreate) *CoinBaseCreateBulk {
	return &CoinBaseCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinBase.
func (c *CoinBaseClient) Update() *CoinBaseUpdate {
	mutation := newCoinBaseMutation(c.config, OpUpdate)
	return &CoinBaseUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinBaseClient) UpdateOne(cb *CoinBase) *CoinBaseUpdateOne {
	mutation := newCoinBaseMutation(c.config, OpUpdateOne, withCoinBase(cb))
	return &CoinBaseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinBaseClient) UpdateOneID(id uint32) *CoinBaseUpdateOne {
	mutation := newCoinBaseMutation(c.config, OpUpdateOne, withCoinBaseID(id))
	return &CoinBaseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinBase.
func (c *CoinBaseClient) Delete() *CoinBaseDelete {
	mutation := newCoinBaseMutation(c.config, OpDelete)
	return &CoinBaseDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinBaseClient) DeleteOne(cb *CoinBase) *CoinBaseDeleteOne {
	return c.DeleteOneID(cb.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinBaseClient) DeleteOneID(id uint32) *CoinBaseDeleteOne {
	builder := c.Delete().Where(coinbase.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinBaseDeleteOne{builder}
}

// Query returns a query builder for CoinBase.
func (c *CoinBaseClient) Query() *CoinBaseQuery {
	return &CoinBaseQuery{
		config: c.config,
	}
}

// Get returns a CoinBase entity by its id.
func (c *CoinBaseClient) Get(ctx context.Context, id uint32) (*CoinBase, error) {
	return c.Query().Where(coinbase.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinBaseClient) GetX(ctx context.Context, id uint32) *CoinBase {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinBaseClient) Hooks() []Hook {
	hooks := c.hooks.CoinBase
	return append(hooks[:len(hooks):len(hooks)], coinbase.Hooks[:]...)
}

// CoinDescriptionClient is a client for the CoinDescription schema.
type CoinDescriptionClient struct {
	config
}

// NewCoinDescriptionClient returns a client for the CoinDescription from the given config.
func NewCoinDescriptionClient(c config) *CoinDescriptionClient {
	return &CoinDescriptionClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coindescription.Hooks(f(g(h())))`.
func (c *CoinDescriptionClient) Use(hooks ...Hook) {
	c.hooks.CoinDescription = append(c.hooks.CoinDescription, hooks...)
}

// Create returns a builder for creating a CoinDescription entity.
func (c *CoinDescriptionClient) Create() *CoinDescriptionCreate {
	mutation := newCoinDescriptionMutation(c.config, OpCreate)
	return &CoinDescriptionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinDescription entities.
func (c *CoinDescriptionClient) CreateBulk(builders ...*CoinDescriptionCreate) *CoinDescriptionCreateBulk {
	return &CoinDescriptionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinDescription.
func (c *CoinDescriptionClient) Update() *CoinDescriptionUpdate {
	mutation := newCoinDescriptionMutation(c.config, OpUpdate)
	return &CoinDescriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinDescriptionClient) UpdateOne(cd *CoinDescription) *CoinDescriptionUpdateOne {
	mutation := newCoinDescriptionMutation(c.config, OpUpdateOne, withCoinDescription(cd))
	return &CoinDescriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinDescriptionClient) UpdateOneID(id uint32) *CoinDescriptionUpdateOne {
	mutation := newCoinDescriptionMutation(c.config, OpUpdateOne, withCoinDescriptionID(id))
	return &CoinDescriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinDescription.
func (c *CoinDescriptionClient) Delete() *CoinDescriptionDelete {
	mutation := newCoinDescriptionMutation(c.config, OpDelete)
	return &CoinDescriptionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinDescriptionClient) DeleteOne(cd *CoinDescription) *CoinDescriptionDeleteOne {
	return c.DeleteOneID(cd.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinDescriptionClient) DeleteOneID(id uint32) *CoinDescriptionDeleteOne {
	builder := c.Delete().Where(coindescription.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinDescriptionDeleteOne{builder}
}

// Query returns a query builder for CoinDescription.
func (c *CoinDescriptionClient) Query() *CoinDescriptionQuery {
	return &CoinDescriptionQuery{
		config: c.config,
	}
}

// Get returns a CoinDescription entity by its id.
func (c *CoinDescriptionClient) Get(ctx context.Context, id uint32) (*CoinDescription, error) {
	return c.Query().Where(coindescription.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinDescriptionClient) GetX(ctx context.Context, id uint32) *CoinDescription {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinDescriptionClient) Hooks() []Hook {
	hooks := c.hooks.CoinDescription
	return append(hooks[:len(hooks):len(hooks)], coindescription.Hooks[:]...)
}

// CoinExtraClient is a client for the CoinExtra schema.
type CoinExtraClient struct {
	config
}

// NewCoinExtraClient returns a client for the CoinExtra from the given config.
func NewCoinExtraClient(c config) *CoinExtraClient {
	return &CoinExtraClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinextra.Hooks(f(g(h())))`.
func (c *CoinExtraClient) Use(hooks ...Hook) {
	c.hooks.CoinExtra = append(c.hooks.CoinExtra, hooks...)
}

// Create returns a builder for creating a CoinExtra entity.
func (c *CoinExtraClient) Create() *CoinExtraCreate {
	mutation := newCoinExtraMutation(c.config, OpCreate)
	return &CoinExtraCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinExtra entities.
func (c *CoinExtraClient) CreateBulk(builders ...*CoinExtraCreate) *CoinExtraCreateBulk {
	return &CoinExtraCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinExtra.
func (c *CoinExtraClient) Update() *CoinExtraUpdate {
	mutation := newCoinExtraMutation(c.config, OpUpdate)
	return &CoinExtraUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinExtraClient) UpdateOne(ce *CoinExtra) *CoinExtraUpdateOne {
	mutation := newCoinExtraMutation(c.config, OpUpdateOne, withCoinExtra(ce))
	return &CoinExtraUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinExtraClient) UpdateOneID(id uint32) *CoinExtraUpdateOne {
	mutation := newCoinExtraMutation(c.config, OpUpdateOne, withCoinExtraID(id))
	return &CoinExtraUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinExtra.
func (c *CoinExtraClient) Delete() *CoinExtraDelete {
	mutation := newCoinExtraMutation(c.config, OpDelete)
	return &CoinExtraDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinExtraClient) DeleteOne(ce *CoinExtra) *CoinExtraDeleteOne {
	return c.DeleteOneID(ce.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinExtraClient) DeleteOneID(id uint32) *CoinExtraDeleteOne {
	builder := c.Delete().Where(coinextra.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinExtraDeleteOne{builder}
}

// Query returns a query builder for CoinExtra.
func (c *CoinExtraClient) Query() *CoinExtraQuery {
	return &CoinExtraQuery{
		config: c.config,
	}
}

// Get returns a CoinExtra entity by its id.
func (c *CoinExtraClient) Get(ctx context.Context, id uint32) (*CoinExtra, error) {
	return c.Query().Where(coinextra.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinExtraClient) GetX(ctx context.Context, id uint32) *CoinExtra {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinExtraClient) Hooks() []Hook {
	hooks := c.hooks.CoinExtra
	return append(hooks[:len(hooks):len(hooks)], coinextra.Hooks[:]...)
}

// CoinFiatClient is a client for the CoinFiat schema.
type CoinFiatClient struct {
	config
}

// NewCoinFiatClient returns a client for the CoinFiat from the given config.
func NewCoinFiatClient(c config) *CoinFiatClient {
	return &CoinFiatClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinfiat.Hooks(f(g(h())))`.
func (c *CoinFiatClient) Use(hooks ...Hook) {
	c.hooks.CoinFiat = append(c.hooks.CoinFiat, hooks...)
}

// Create returns a builder for creating a CoinFiat entity.
func (c *CoinFiatClient) Create() *CoinFiatCreate {
	mutation := newCoinFiatMutation(c.config, OpCreate)
	return &CoinFiatCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinFiat entities.
func (c *CoinFiatClient) CreateBulk(builders ...*CoinFiatCreate) *CoinFiatCreateBulk {
	return &CoinFiatCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinFiat.
func (c *CoinFiatClient) Update() *CoinFiatUpdate {
	mutation := newCoinFiatMutation(c.config, OpUpdate)
	return &CoinFiatUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinFiatClient) UpdateOne(cf *CoinFiat) *CoinFiatUpdateOne {
	mutation := newCoinFiatMutation(c.config, OpUpdateOne, withCoinFiat(cf))
	return &CoinFiatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinFiatClient) UpdateOneID(id uint32) *CoinFiatUpdateOne {
	mutation := newCoinFiatMutation(c.config, OpUpdateOne, withCoinFiatID(id))
	return &CoinFiatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinFiat.
func (c *CoinFiatClient) Delete() *CoinFiatDelete {
	mutation := newCoinFiatMutation(c.config, OpDelete)
	return &CoinFiatDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinFiatClient) DeleteOne(cf *CoinFiat) *CoinFiatDeleteOne {
	return c.DeleteOneID(cf.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinFiatClient) DeleteOneID(id uint32) *CoinFiatDeleteOne {
	builder := c.Delete().Where(coinfiat.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinFiatDeleteOne{builder}
}

// Query returns a query builder for CoinFiat.
func (c *CoinFiatClient) Query() *CoinFiatQuery {
	return &CoinFiatQuery{
		config: c.config,
	}
}

// Get returns a CoinFiat entity by its id.
func (c *CoinFiatClient) Get(ctx context.Context, id uint32) (*CoinFiat, error) {
	return c.Query().Where(coinfiat.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinFiatClient) GetX(ctx context.Context, id uint32) *CoinFiat {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinFiatClient) Hooks() []Hook {
	hooks := c.hooks.CoinFiat
	return append(hooks[:len(hooks):len(hooks)], coinfiat.Hooks[:]...)
}

// CoinFiatCurrencyClient is a client for the CoinFiatCurrency schema.
type CoinFiatCurrencyClient struct {
	config
}

// NewCoinFiatCurrencyClient returns a client for the CoinFiatCurrency from the given config.
func NewCoinFiatCurrencyClient(c config) *CoinFiatCurrencyClient {
	return &CoinFiatCurrencyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinfiatcurrency.Hooks(f(g(h())))`.
func (c *CoinFiatCurrencyClient) Use(hooks ...Hook) {
	c.hooks.CoinFiatCurrency = append(c.hooks.CoinFiatCurrency, hooks...)
}

// Create returns a builder for creating a CoinFiatCurrency entity.
func (c *CoinFiatCurrencyClient) Create() *CoinFiatCurrencyCreate {
	mutation := newCoinFiatCurrencyMutation(c.config, OpCreate)
	return &CoinFiatCurrencyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinFiatCurrency entities.
func (c *CoinFiatCurrencyClient) CreateBulk(builders ...*CoinFiatCurrencyCreate) *CoinFiatCurrencyCreateBulk {
	return &CoinFiatCurrencyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinFiatCurrency.
func (c *CoinFiatCurrencyClient) Update() *CoinFiatCurrencyUpdate {
	mutation := newCoinFiatCurrencyMutation(c.config, OpUpdate)
	return &CoinFiatCurrencyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinFiatCurrencyClient) UpdateOne(cfc *CoinFiatCurrency) *CoinFiatCurrencyUpdateOne {
	mutation := newCoinFiatCurrencyMutation(c.config, OpUpdateOne, withCoinFiatCurrency(cfc))
	return &CoinFiatCurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinFiatCurrencyClient) UpdateOneID(id uint32) *CoinFiatCurrencyUpdateOne {
	mutation := newCoinFiatCurrencyMutation(c.config, OpUpdateOne, withCoinFiatCurrencyID(id))
	return &CoinFiatCurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinFiatCurrency.
func (c *CoinFiatCurrencyClient) Delete() *CoinFiatCurrencyDelete {
	mutation := newCoinFiatCurrencyMutation(c.config, OpDelete)
	return &CoinFiatCurrencyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinFiatCurrencyClient) DeleteOne(cfc *CoinFiatCurrency) *CoinFiatCurrencyDeleteOne {
	return c.DeleteOneID(cfc.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinFiatCurrencyClient) DeleteOneID(id uint32) *CoinFiatCurrencyDeleteOne {
	builder := c.Delete().Where(coinfiatcurrency.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinFiatCurrencyDeleteOne{builder}
}

// Query returns a query builder for CoinFiatCurrency.
func (c *CoinFiatCurrencyClient) Query() *CoinFiatCurrencyQuery {
	return &CoinFiatCurrencyQuery{
		config: c.config,
	}
}

// Get returns a CoinFiatCurrency entity by its id.
func (c *CoinFiatCurrencyClient) Get(ctx context.Context, id uint32) (*CoinFiatCurrency, error) {
	return c.Query().Where(coinfiatcurrency.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinFiatCurrencyClient) GetX(ctx context.Context, id uint32) *CoinFiatCurrency {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinFiatCurrencyClient) Hooks() []Hook {
	hooks := c.hooks.CoinFiatCurrency
	return append(hooks[:len(hooks):len(hooks)], coinfiatcurrency.Hooks[:]...)
}

// CoinFiatCurrencyHistoryClient is a client for the CoinFiatCurrencyHistory schema.
type CoinFiatCurrencyHistoryClient struct {
	config
}

// NewCoinFiatCurrencyHistoryClient returns a client for the CoinFiatCurrencyHistory from the given config.
func NewCoinFiatCurrencyHistoryClient(c config) *CoinFiatCurrencyHistoryClient {
	return &CoinFiatCurrencyHistoryClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinfiatcurrencyhistory.Hooks(f(g(h())))`.
func (c *CoinFiatCurrencyHistoryClient) Use(hooks ...Hook) {
	c.hooks.CoinFiatCurrencyHistory = append(c.hooks.CoinFiatCurrencyHistory, hooks...)
}

// Create returns a builder for creating a CoinFiatCurrencyHistory entity.
func (c *CoinFiatCurrencyHistoryClient) Create() *CoinFiatCurrencyHistoryCreate {
	mutation := newCoinFiatCurrencyHistoryMutation(c.config, OpCreate)
	return &CoinFiatCurrencyHistoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinFiatCurrencyHistory entities.
func (c *CoinFiatCurrencyHistoryClient) CreateBulk(builders ...*CoinFiatCurrencyHistoryCreate) *CoinFiatCurrencyHistoryCreateBulk {
	return &CoinFiatCurrencyHistoryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinFiatCurrencyHistory.
func (c *CoinFiatCurrencyHistoryClient) Update() *CoinFiatCurrencyHistoryUpdate {
	mutation := newCoinFiatCurrencyHistoryMutation(c.config, OpUpdate)
	return &CoinFiatCurrencyHistoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinFiatCurrencyHistoryClient) UpdateOne(cfch *CoinFiatCurrencyHistory) *CoinFiatCurrencyHistoryUpdateOne {
	mutation := newCoinFiatCurrencyHistoryMutation(c.config, OpUpdateOne, withCoinFiatCurrencyHistory(cfch))
	return &CoinFiatCurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinFiatCurrencyHistoryClient) UpdateOneID(id uint32) *CoinFiatCurrencyHistoryUpdateOne {
	mutation := newCoinFiatCurrencyHistoryMutation(c.config, OpUpdateOne, withCoinFiatCurrencyHistoryID(id))
	return &CoinFiatCurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinFiatCurrencyHistory.
func (c *CoinFiatCurrencyHistoryClient) Delete() *CoinFiatCurrencyHistoryDelete {
	mutation := newCoinFiatCurrencyHistoryMutation(c.config, OpDelete)
	return &CoinFiatCurrencyHistoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinFiatCurrencyHistoryClient) DeleteOne(cfch *CoinFiatCurrencyHistory) *CoinFiatCurrencyHistoryDeleteOne {
	return c.DeleteOneID(cfch.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinFiatCurrencyHistoryClient) DeleteOneID(id uint32) *CoinFiatCurrencyHistoryDeleteOne {
	builder := c.Delete().Where(coinfiatcurrencyhistory.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinFiatCurrencyHistoryDeleteOne{builder}
}

// Query returns a query builder for CoinFiatCurrencyHistory.
func (c *CoinFiatCurrencyHistoryClient) Query() *CoinFiatCurrencyHistoryQuery {
	return &CoinFiatCurrencyHistoryQuery{
		config: c.config,
	}
}

// Get returns a CoinFiatCurrencyHistory entity by its id.
func (c *CoinFiatCurrencyHistoryClient) Get(ctx context.Context, id uint32) (*CoinFiatCurrencyHistory, error) {
	return c.Query().Where(coinfiatcurrencyhistory.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinFiatCurrencyHistoryClient) GetX(ctx context.Context, id uint32) *CoinFiatCurrencyHistory {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinFiatCurrencyHistoryClient) Hooks() []Hook {
	hooks := c.hooks.CoinFiatCurrencyHistory
	return append(hooks[:len(hooks):len(hooks)], coinfiatcurrencyhistory.Hooks[:]...)
}

// CoinUsedForClient is a client for the CoinUsedFor schema.
type CoinUsedForClient struct {
	config
}

// NewCoinUsedForClient returns a client for the CoinUsedFor from the given config.
func NewCoinUsedForClient(c config) *CoinUsedForClient {
	return &CoinUsedForClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `coinusedfor.Hooks(f(g(h())))`.
func (c *CoinUsedForClient) Use(hooks ...Hook) {
	c.hooks.CoinUsedFor = append(c.hooks.CoinUsedFor, hooks...)
}

// Create returns a builder for creating a CoinUsedFor entity.
func (c *CoinUsedForClient) Create() *CoinUsedForCreate {
	mutation := newCoinUsedForMutation(c.config, OpCreate)
	return &CoinUsedForCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CoinUsedFor entities.
func (c *CoinUsedForClient) CreateBulk(builders ...*CoinUsedForCreate) *CoinUsedForCreateBulk {
	return &CoinUsedForCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CoinUsedFor.
func (c *CoinUsedForClient) Update() *CoinUsedForUpdate {
	mutation := newCoinUsedForMutation(c.config, OpUpdate)
	return &CoinUsedForUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CoinUsedForClient) UpdateOne(cuf *CoinUsedFor) *CoinUsedForUpdateOne {
	mutation := newCoinUsedForMutation(c.config, OpUpdateOne, withCoinUsedFor(cuf))
	return &CoinUsedForUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CoinUsedForClient) UpdateOneID(id uint32) *CoinUsedForUpdateOne {
	mutation := newCoinUsedForMutation(c.config, OpUpdateOne, withCoinUsedForID(id))
	return &CoinUsedForUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CoinUsedFor.
func (c *CoinUsedForClient) Delete() *CoinUsedForDelete {
	mutation := newCoinUsedForMutation(c.config, OpDelete)
	return &CoinUsedForDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CoinUsedForClient) DeleteOne(cuf *CoinUsedFor) *CoinUsedForDeleteOne {
	return c.DeleteOneID(cuf.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CoinUsedForClient) DeleteOneID(id uint32) *CoinUsedForDeleteOne {
	builder := c.Delete().Where(coinusedfor.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CoinUsedForDeleteOne{builder}
}

// Query returns a query builder for CoinUsedFor.
func (c *CoinUsedForClient) Query() *CoinUsedForQuery {
	return &CoinUsedForQuery{
		config: c.config,
	}
}

// Get returns a CoinUsedFor entity by its id.
func (c *CoinUsedForClient) Get(ctx context.Context, id uint32) (*CoinUsedFor, error) {
	return c.Query().Where(coinusedfor.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CoinUsedForClient) GetX(ctx context.Context, id uint32) *CoinUsedFor {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CoinUsedForClient) Hooks() []Hook {
	hooks := c.hooks.CoinUsedFor
	return append(hooks[:len(hooks):len(hooks)], coinusedfor.Hooks[:]...)
}

// CurrencyClient is a client for the Currency schema.
type CurrencyClient struct {
	config
}

// NewCurrencyClient returns a client for the Currency from the given config.
func NewCurrencyClient(c config) *CurrencyClient {
	return &CurrencyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `currency.Hooks(f(g(h())))`.
func (c *CurrencyClient) Use(hooks ...Hook) {
	c.hooks.Currency = append(c.hooks.Currency, hooks...)
}

// Create returns a builder for creating a Currency entity.
func (c *CurrencyClient) Create() *CurrencyCreate {
	mutation := newCurrencyMutation(c.config, OpCreate)
	return &CurrencyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Currency entities.
func (c *CurrencyClient) CreateBulk(builders ...*CurrencyCreate) *CurrencyCreateBulk {
	return &CurrencyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Currency.
func (c *CurrencyClient) Update() *CurrencyUpdate {
	mutation := newCurrencyMutation(c.config, OpUpdate)
	return &CurrencyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CurrencyClient) UpdateOne(cu *Currency) *CurrencyUpdateOne {
	mutation := newCurrencyMutation(c.config, OpUpdateOne, withCurrency(cu))
	return &CurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CurrencyClient) UpdateOneID(id uint32) *CurrencyUpdateOne {
	mutation := newCurrencyMutation(c.config, OpUpdateOne, withCurrencyID(id))
	return &CurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Currency.
func (c *CurrencyClient) Delete() *CurrencyDelete {
	mutation := newCurrencyMutation(c.config, OpDelete)
	return &CurrencyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CurrencyClient) DeleteOne(cu *Currency) *CurrencyDeleteOne {
	return c.DeleteOneID(cu.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CurrencyClient) DeleteOneID(id uint32) *CurrencyDeleteOne {
	builder := c.Delete().Where(currency.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CurrencyDeleteOne{builder}
}

// Query returns a query builder for Currency.
func (c *CurrencyClient) Query() *CurrencyQuery {
	return &CurrencyQuery{
		config: c.config,
	}
}

// Get returns a Currency entity by its id.
func (c *CurrencyClient) Get(ctx context.Context, id uint32) (*Currency, error) {
	return c.Query().Where(currency.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CurrencyClient) GetX(ctx context.Context, id uint32) *Currency {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CurrencyClient) Hooks() []Hook {
	hooks := c.hooks.Currency
	return append(hooks[:len(hooks):len(hooks)], currency.Hooks[:]...)
}

// CurrencyFeedClient is a client for the CurrencyFeed schema.
type CurrencyFeedClient struct {
	config
}

// NewCurrencyFeedClient returns a client for the CurrencyFeed from the given config.
func NewCurrencyFeedClient(c config) *CurrencyFeedClient {
	return &CurrencyFeedClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `currencyfeed.Hooks(f(g(h())))`.
func (c *CurrencyFeedClient) Use(hooks ...Hook) {
	c.hooks.CurrencyFeed = append(c.hooks.CurrencyFeed, hooks...)
}

// Create returns a builder for creating a CurrencyFeed entity.
func (c *CurrencyFeedClient) Create() *CurrencyFeedCreate {
	mutation := newCurrencyFeedMutation(c.config, OpCreate)
	return &CurrencyFeedCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CurrencyFeed entities.
func (c *CurrencyFeedClient) CreateBulk(builders ...*CurrencyFeedCreate) *CurrencyFeedCreateBulk {
	return &CurrencyFeedCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CurrencyFeed.
func (c *CurrencyFeedClient) Update() *CurrencyFeedUpdate {
	mutation := newCurrencyFeedMutation(c.config, OpUpdate)
	return &CurrencyFeedUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CurrencyFeedClient) UpdateOne(cf *CurrencyFeed) *CurrencyFeedUpdateOne {
	mutation := newCurrencyFeedMutation(c.config, OpUpdateOne, withCurrencyFeed(cf))
	return &CurrencyFeedUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CurrencyFeedClient) UpdateOneID(id uint32) *CurrencyFeedUpdateOne {
	mutation := newCurrencyFeedMutation(c.config, OpUpdateOne, withCurrencyFeedID(id))
	return &CurrencyFeedUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CurrencyFeed.
func (c *CurrencyFeedClient) Delete() *CurrencyFeedDelete {
	mutation := newCurrencyFeedMutation(c.config, OpDelete)
	return &CurrencyFeedDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CurrencyFeedClient) DeleteOne(cf *CurrencyFeed) *CurrencyFeedDeleteOne {
	return c.DeleteOneID(cf.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CurrencyFeedClient) DeleteOneID(id uint32) *CurrencyFeedDeleteOne {
	builder := c.Delete().Where(currencyfeed.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CurrencyFeedDeleteOne{builder}
}

// Query returns a query builder for CurrencyFeed.
func (c *CurrencyFeedClient) Query() *CurrencyFeedQuery {
	return &CurrencyFeedQuery{
		config: c.config,
	}
}

// Get returns a CurrencyFeed entity by its id.
func (c *CurrencyFeedClient) Get(ctx context.Context, id uint32) (*CurrencyFeed, error) {
	return c.Query().Where(currencyfeed.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CurrencyFeedClient) GetX(ctx context.Context, id uint32) *CurrencyFeed {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CurrencyFeedClient) Hooks() []Hook {
	hooks := c.hooks.CurrencyFeed
	return append(hooks[:len(hooks):len(hooks)], currencyfeed.Hooks[:]...)
}

// CurrencyHistoryClient is a client for the CurrencyHistory schema.
type CurrencyHistoryClient struct {
	config
}

// NewCurrencyHistoryClient returns a client for the CurrencyHistory from the given config.
func NewCurrencyHistoryClient(c config) *CurrencyHistoryClient {
	return &CurrencyHistoryClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `currencyhistory.Hooks(f(g(h())))`.
func (c *CurrencyHistoryClient) Use(hooks ...Hook) {
	c.hooks.CurrencyHistory = append(c.hooks.CurrencyHistory, hooks...)
}

// Create returns a builder for creating a CurrencyHistory entity.
func (c *CurrencyHistoryClient) Create() *CurrencyHistoryCreate {
	mutation := newCurrencyHistoryMutation(c.config, OpCreate)
	return &CurrencyHistoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of CurrencyHistory entities.
func (c *CurrencyHistoryClient) CreateBulk(builders ...*CurrencyHistoryCreate) *CurrencyHistoryCreateBulk {
	return &CurrencyHistoryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for CurrencyHistory.
func (c *CurrencyHistoryClient) Update() *CurrencyHistoryUpdate {
	mutation := newCurrencyHistoryMutation(c.config, OpUpdate)
	return &CurrencyHistoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CurrencyHistoryClient) UpdateOne(ch *CurrencyHistory) *CurrencyHistoryUpdateOne {
	mutation := newCurrencyHistoryMutation(c.config, OpUpdateOne, withCurrencyHistory(ch))
	return &CurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CurrencyHistoryClient) UpdateOneID(id uint32) *CurrencyHistoryUpdateOne {
	mutation := newCurrencyHistoryMutation(c.config, OpUpdateOne, withCurrencyHistoryID(id))
	return &CurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for CurrencyHistory.
func (c *CurrencyHistoryClient) Delete() *CurrencyHistoryDelete {
	mutation := newCurrencyHistoryMutation(c.config, OpDelete)
	return &CurrencyHistoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CurrencyHistoryClient) DeleteOne(ch *CurrencyHistory) *CurrencyHistoryDeleteOne {
	return c.DeleteOneID(ch.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *CurrencyHistoryClient) DeleteOneID(id uint32) *CurrencyHistoryDeleteOne {
	builder := c.Delete().Where(currencyhistory.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CurrencyHistoryDeleteOne{builder}
}

// Query returns a query builder for CurrencyHistory.
func (c *CurrencyHistoryClient) Query() *CurrencyHistoryQuery {
	return &CurrencyHistoryQuery{
		config: c.config,
	}
}

// Get returns a CurrencyHistory entity by its id.
func (c *CurrencyHistoryClient) Get(ctx context.Context, id uint32) (*CurrencyHistory, error) {
	return c.Query().Where(currencyhistory.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CurrencyHistoryClient) GetX(ctx context.Context, id uint32) *CurrencyHistory {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *CurrencyHistoryClient) Hooks() []Hook {
	hooks := c.hooks.CurrencyHistory
	return append(hooks[:len(hooks):len(hooks)], currencyhistory.Hooks[:]...)
}

// ExchangeRateClient is a client for the ExchangeRate schema.
type ExchangeRateClient struct {
	config
}

// NewExchangeRateClient returns a client for the ExchangeRate from the given config.
func NewExchangeRateClient(c config) *ExchangeRateClient {
	return &ExchangeRateClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `exchangerate.Hooks(f(g(h())))`.
func (c *ExchangeRateClient) Use(hooks ...Hook) {
	c.hooks.ExchangeRate = append(c.hooks.ExchangeRate, hooks...)
}

// Create returns a builder for creating a ExchangeRate entity.
func (c *ExchangeRateClient) Create() *ExchangeRateCreate {
	mutation := newExchangeRateMutation(c.config, OpCreate)
	return &ExchangeRateCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ExchangeRate entities.
func (c *ExchangeRateClient) CreateBulk(builders ...*ExchangeRateCreate) *ExchangeRateCreateBulk {
	return &ExchangeRateCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ExchangeRate.
func (c *ExchangeRateClient) Update() *ExchangeRateUpdate {
	mutation := newExchangeRateMutation(c.config, OpUpdate)
	return &ExchangeRateUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ExchangeRateClient) UpdateOne(er *ExchangeRate) *ExchangeRateUpdateOne {
	mutation := newExchangeRateMutation(c.config, OpUpdateOne, withExchangeRate(er))
	return &ExchangeRateUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ExchangeRateClient) UpdateOneID(id uint32) *ExchangeRateUpdateOne {
	mutation := newExchangeRateMutation(c.config, OpUpdateOne, withExchangeRateID(id))
	return &ExchangeRateUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ExchangeRate.
func (c *ExchangeRateClient) Delete() *ExchangeRateDelete {
	mutation := newExchangeRateMutation(c.config, OpDelete)
	return &ExchangeRateDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ExchangeRateClient) DeleteOne(er *ExchangeRate) *ExchangeRateDeleteOne {
	return c.DeleteOneID(er.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ExchangeRateClient) DeleteOneID(id uint32) *ExchangeRateDeleteOne {
	builder := c.Delete().Where(exchangerate.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ExchangeRateDeleteOne{builder}
}

// Query returns a query builder for ExchangeRate.
func (c *ExchangeRateClient) Query() *ExchangeRateQuery {
	return &ExchangeRateQuery{
		config: c.config,
	}
}

// Get returns a ExchangeRate entity by its id.
func (c *ExchangeRateClient) Get(ctx context.Context, id uint32) (*ExchangeRate, error) {
	return c.Query().Where(exchangerate.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ExchangeRateClient) GetX(ctx context.Context, id uint32) *ExchangeRate {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *ExchangeRateClient) Hooks() []Hook {
	hooks := c.hooks.ExchangeRate
	return append(hooks[:len(hooks):len(hooks)], exchangerate.Hooks[:]...)
}

// FiatClient is a client for the Fiat schema.
type FiatClient struct {
	config
}

// NewFiatClient returns a client for the Fiat from the given config.
func NewFiatClient(c config) *FiatClient {
	return &FiatClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `fiat.Hooks(f(g(h())))`.
func (c *FiatClient) Use(hooks ...Hook) {
	c.hooks.Fiat = append(c.hooks.Fiat, hooks...)
}

// Create returns a builder for creating a Fiat entity.
func (c *FiatClient) Create() *FiatCreate {
	mutation := newFiatMutation(c.config, OpCreate)
	return &FiatCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Fiat entities.
func (c *FiatClient) CreateBulk(builders ...*FiatCreate) *FiatCreateBulk {
	return &FiatCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Fiat.
func (c *FiatClient) Update() *FiatUpdate {
	mutation := newFiatMutation(c.config, OpUpdate)
	return &FiatUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FiatClient) UpdateOne(f *Fiat) *FiatUpdateOne {
	mutation := newFiatMutation(c.config, OpUpdateOne, withFiat(f))
	return &FiatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FiatClient) UpdateOneID(id uint32) *FiatUpdateOne {
	mutation := newFiatMutation(c.config, OpUpdateOne, withFiatID(id))
	return &FiatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Fiat.
func (c *FiatClient) Delete() *FiatDelete {
	mutation := newFiatMutation(c.config, OpDelete)
	return &FiatDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FiatClient) DeleteOne(f *Fiat) *FiatDeleteOne {
	return c.DeleteOneID(f.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *FiatClient) DeleteOneID(id uint32) *FiatDeleteOne {
	builder := c.Delete().Where(fiat.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &FiatDeleteOne{builder}
}

// Query returns a query builder for Fiat.
func (c *FiatClient) Query() *FiatQuery {
	return &FiatQuery{
		config: c.config,
	}
}

// Get returns a Fiat entity by its id.
func (c *FiatClient) Get(ctx context.Context, id uint32) (*Fiat, error) {
	return c.Query().Where(fiat.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *FiatClient) GetX(ctx context.Context, id uint32) *Fiat {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *FiatClient) Hooks() []Hook {
	hooks := c.hooks.Fiat
	return append(hooks[:len(hooks):len(hooks)], fiat.Hooks[:]...)
}

// FiatCurrencyClient is a client for the FiatCurrency schema.
type FiatCurrencyClient struct {
	config
}

// NewFiatCurrencyClient returns a client for the FiatCurrency from the given config.
func NewFiatCurrencyClient(c config) *FiatCurrencyClient {
	return &FiatCurrencyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `fiatcurrency.Hooks(f(g(h())))`.
func (c *FiatCurrencyClient) Use(hooks ...Hook) {
	c.hooks.FiatCurrency = append(c.hooks.FiatCurrency, hooks...)
}

// Create returns a builder for creating a FiatCurrency entity.
func (c *FiatCurrencyClient) Create() *FiatCurrencyCreate {
	mutation := newFiatCurrencyMutation(c.config, OpCreate)
	return &FiatCurrencyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of FiatCurrency entities.
func (c *FiatCurrencyClient) CreateBulk(builders ...*FiatCurrencyCreate) *FiatCurrencyCreateBulk {
	return &FiatCurrencyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for FiatCurrency.
func (c *FiatCurrencyClient) Update() *FiatCurrencyUpdate {
	mutation := newFiatCurrencyMutation(c.config, OpUpdate)
	return &FiatCurrencyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FiatCurrencyClient) UpdateOne(fc *FiatCurrency) *FiatCurrencyUpdateOne {
	mutation := newFiatCurrencyMutation(c.config, OpUpdateOne, withFiatCurrency(fc))
	return &FiatCurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FiatCurrencyClient) UpdateOneID(id uint32) *FiatCurrencyUpdateOne {
	mutation := newFiatCurrencyMutation(c.config, OpUpdateOne, withFiatCurrencyID(id))
	return &FiatCurrencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for FiatCurrency.
func (c *FiatCurrencyClient) Delete() *FiatCurrencyDelete {
	mutation := newFiatCurrencyMutation(c.config, OpDelete)
	return &FiatCurrencyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FiatCurrencyClient) DeleteOne(fc *FiatCurrency) *FiatCurrencyDeleteOne {
	return c.DeleteOneID(fc.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *FiatCurrencyClient) DeleteOneID(id uint32) *FiatCurrencyDeleteOne {
	builder := c.Delete().Where(fiatcurrency.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &FiatCurrencyDeleteOne{builder}
}

// Query returns a query builder for FiatCurrency.
func (c *FiatCurrencyClient) Query() *FiatCurrencyQuery {
	return &FiatCurrencyQuery{
		config: c.config,
	}
}

// Get returns a FiatCurrency entity by its id.
func (c *FiatCurrencyClient) Get(ctx context.Context, id uint32) (*FiatCurrency, error) {
	return c.Query().Where(fiatcurrency.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *FiatCurrencyClient) GetX(ctx context.Context, id uint32) *FiatCurrency {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *FiatCurrencyClient) Hooks() []Hook {
	hooks := c.hooks.FiatCurrency
	return append(hooks[:len(hooks):len(hooks)], fiatcurrency.Hooks[:]...)
}

// FiatCurrencyFeedClient is a client for the FiatCurrencyFeed schema.
type FiatCurrencyFeedClient struct {
	config
}

// NewFiatCurrencyFeedClient returns a client for the FiatCurrencyFeed from the given config.
func NewFiatCurrencyFeedClient(c config) *FiatCurrencyFeedClient {
	return &FiatCurrencyFeedClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `fiatcurrencyfeed.Hooks(f(g(h())))`.
func (c *FiatCurrencyFeedClient) Use(hooks ...Hook) {
	c.hooks.FiatCurrencyFeed = append(c.hooks.FiatCurrencyFeed, hooks...)
}

// Create returns a builder for creating a FiatCurrencyFeed entity.
func (c *FiatCurrencyFeedClient) Create() *FiatCurrencyFeedCreate {
	mutation := newFiatCurrencyFeedMutation(c.config, OpCreate)
	return &FiatCurrencyFeedCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of FiatCurrencyFeed entities.
func (c *FiatCurrencyFeedClient) CreateBulk(builders ...*FiatCurrencyFeedCreate) *FiatCurrencyFeedCreateBulk {
	return &FiatCurrencyFeedCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for FiatCurrencyFeed.
func (c *FiatCurrencyFeedClient) Update() *FiatCurrencyFeedUpdate {
	mutation := newFiatCurrencyFeedMutation(c.config, OpUpdate)
	return &FiatCurrencyFeedUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FiatCurrencyFeedClient) UpdateOne(fcf *FiatCurrencyFeed) *FiatCurrencyFeedUpdateOne {
	mutation := newFiatCurrencyFeedMutation(c.config, OpUpdateOne, withFiatCurrencyFeed(fcf))
	return &FiatCurrencyFeedUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FiatCurrencyFeedClient) UpdateOneID(id uint32) *FiatCurrencyFeedUpdateOne {
	mutation := newFiatCurrencyFeedMutation(c.config, OpUpdateOne, withFiatCurrencyFeedID(id))
	return &FiatCurrencyFeedUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for FiatCurrencyFeed.
func (c *FiatCurrencyFeedClient) Delete() *FiatCurrencyFeedDelete {
	mutation := newFiatCurrencyFeedMutation(c.config, OpDelete)
	return &FiatCurrencyFeedDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FiatCurrencyFeedClient) DeleteOne(fcf *FiatCurrencyFeed) *FiatCurrencyFeedDeleteOne {
	return c.DeleteOneID(fcf.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *FiatCurrencyFeedClient) DeleteOneID(id uint32) *FiatCurrencyFeedDeleteOne {
	builder := c.Delete().Where(fiatcurrencyfeed.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &FiatCurrencyFeedDeleteOne{builder}
}

// Query returns a query builder for FiatCurrencyFeed.
func (c *FiatCurrencyFeedClient) Query() *FiatCurrencyFeedQuery {
	return &FiatCurrencyFeedQuery{
		config: c.config,
	}
}

// Get returns a FiatCurrencyFeed entity by its id.
func (c *FiatCurrencyFeedClient) Get(ctx context.Context, id uint32) (*FiatCurrencyFeed, error) {
	return c.Query().Where(fiatcurrencyfeed.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *FiatCurrencyFeedClient) GetX(ctx context.Context, id uint32) *FiatCurrencyFeed {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *FiatCurrencyFeedClient) Hooks() []Hook {
	hooks := c.hooks.FiatCurrencyFeed
	return append(hooks[:len(hooks):len(hooks)], fiatcurrencyfeed.Hooks[:]...)
}

// FiatCurrencyHistoryClient is a client for the FiatCurrencyHistory schema.
type FiatCurrencyHistoryClient struct {
	config
}

// NewFiatCurrencyHistoryClient returns a client for the FiatCurrencyHistory from the given config.
func NewFiatCurrencyHistoryClient(c config) *FiatCurrencyHistoryClient {
	return &FiatCurrencyHistoryClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `fiatcurrencyhistory.Hooks(f(g(h())))`.
func (c *FiatCurrencyHistoryClient) Use(hooks ...Hook) {
	c.hooks.FiatCurrencyHistory = append(c.hooks.FiatCurrencyHistory, hooks...)
}

// Create returns a builder for creating a FiatCurrencyHistory entity.
func (c *FiatCurrencyHistoryClient) Create() *FiatCurrencyHistoryCreate {
	mutation := newFiatCurrencyHistoryMutation(c.config, OpCreate)
	return &FiatCurrencyHistoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of FiatCurrencyHistory entities.
func (c *FiatCurrencyHistoryClient) CreateBulk(builders ...*FiatCurrencyHistoryCreate) *FiatCurrencyHistoryCreateBulk {
	return &FiatCurrencyHistoryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for FiatCurrencyHistory.
func (c *FiatCurrencyHistoryClient) Update() *FiatCurrencyHistoryUpdate {
	mutation := newFiatCurrencyHistoryMutation(c.config, OpUpdate)
	return &FiatCurrencyHistoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FiatCurrencyHistoryClient) UpdateOne(fch *FiatCurrencyHistory) *FiatCurrencyHistoryUpdateOne {
	mutation := newFiatCurrencyHistoryMutation(c.config, OpUpdateOne, withFiatCurrencyHistory(fch))
	return &FiatCurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FiatCurrencyHistoryClient) UpdateOneID(id uint32) *FiatCurrencyHistoryUpdateOne {
	mutation := newFiatCurrencyHistoryMutation(c.config, OpUpdateOne, withFiatCurrencyHistoryID(id))
	return &FiatCurrencyHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for FiatCurrencyHistory.
func (c *FiatCurrencyHistoryClient) Delete() *FiatCurrencyHistoryDelete {
	mutation := newFiatCurrencyHistoryMutation(c.config, OpDelete)
	return &FiatCurrencyHistoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FiatCurrencyHistoryClient) DeleteOne(fch *FiatCurrencyHistory) *FiatCurrencyHistoryDeleteOne {
	return c.DeleteOneID(fch.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *FiatCurrencyHistoryClient) DeleteOneID(id uint32) *FiatCurrencyHistoryDeleteOne {
	builder := c.Delete().Where(fiatcurrencyhistory.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &FiatCurrencyHistoryDeleteOne{builder}
}

// Query returns a query builder for FiatCurrencyHistory.
func (c *FiatCurrencyHistoryClient) Query() *FiatCurrencyHistoryQuery {
	return &FiatCurrencyHistoryQuery{
		config: c.config,
	}
}

// Get returns a FiatCurrencyHistory entity by its id.
func (c *FiatCurrencyHistoryClient) Get(ctx context.Context, id uint32) (*FiatCurrencyHistory, error) {
	return c.Query().Where(fiatcurrencyhistory.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *FiatCurrencyHistoryClient) GetX(ctx context.Context, id uint32) *FiatCurrencyHistory {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *FiatCurrencyHistoryClient) Hooks() []Hook {
	hooks := c.hooks.FiatCurrencyHistory
	return append(hooks[:len(hooks):len(hooks)], fiatcurrencyhistory.Hooks[:]...)
}

// SettingClient is a client for the Setting schema.
type SettingClient struct {
	config
}

// NewSettingClient returns a client for the Setting from the given config.
func NewSettingClient(c config) *SettingClient {
	return &SettingClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `setting.Hooks(f(g(h())))`.
func (c *SettingClient) Use(hooks ...Hook) {
	c.hooks.Setting = append(c.hooks.Setting, hooks...)
}

// Create returns a builder for creating a Setting entity.
func (c *SettingClient) Create() *SettingCreate {
	mutation := newSettingMutation(c.config, OpCreate)
	return &SettingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Setting entities.
func (c *SettingClient) CreateBulk(builders ...*SettingCreate) *SettingCreateBulk {
	return &SettingCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Setting.
func (c *SettingClient) Update() *SettingUpdate {
	mutation := newSettingMutation(c.config, OpUpdate)
	return &SettingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SettingClient) UpdateOne(s *Setting) *SettingUpdateOne {
	mutation := newSettingMutation(c.config, OpUpdateOne, withSetting(s))
	return &SettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SettingClient) UpdateOneID(id uint32) *SettingUpdateOne {
	mutation := newSettingMutation(c.config, OpUpdateOne, withSettingID(id))
	return &SettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Setting.
func (c *SettingClient) Delete() *SettingDelete {
	mutation := newSettingMutation(c.config, OpDelete)
	return &SettingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SettingClient) DeleteOne(s *Setting) *SettingDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *SettingClient) DeleteOneID(id uint32) *SettingDeleteOne {
	builder := c.Delete().Where(setting.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SettingDeleteOne{builder}
}

// Query returns a query builder for Setting.
func (c *SettingClient) Query() *SettingQuery {
	return &SettingQuery{
		config: c.config,
	}
}

// Get returns a Setting entity by its id.
func (c *SettingClient) Get(ctx context.Context, id uint32) (*Setting, error) {
	return c.Query().Where(setting.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *SettingClient) GetX(ctx context.Context, id uint32) *Setting {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *SettingClient) Hooks() []Hook {
	hooks := c.hooks.Setting
	return append(hooks[:len(hooks):len(hooks)], setting.Hooks[:]...)
}

// TranClient is a client for the Tran schema.
type TranClient struct {
	config
}

// NewTranClient returns a client for the Tran from the given config.
func NewTranClient(c config) *TranClient {
	return &TranClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `tran.Hooks(f(g(h())))`.
func (c *TranClient) Use(hooks ...Hook) {
	c.hooks.Tran = append(c.hooks.Tran, hooks...)
}

// Create returns a builder for creating a Tran entity.
func (c *TranClient) Create() *TranCreate {
	mutation := newTranMutation(c.config, OpCreate)
	return &TranCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Tran entities.
func (c *TranClient) CreateBulk(builders ...*TranCreate) *TranCreateBulk {
	return &TranCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Tran.
func (c *TranClient) Update() *TranUpdate {
	mutation := newTranMutation(c.config, OpUpdate)
	return &TranUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TranClient) UpdateOne(t *Tran) *TranUpdateOne {
	mutation := newTranMutation(c.config, OpUpdateOne, withTran(t))
	return &TranUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TranClient) UpdateOneID(id uint32) *TranUpdateOne {
	mutation := newTranMutation(c.config, OpUpdateOne, withTranID(id))
	return &TranUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Tran.
func (c *TranClient) Delete() *TranDelete {
	mutation := newTranMutation(c.config, OpDelete)
	return &TranDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *TranClient) DeleteOne(t *Tran) *TranDeleteOne {
	return c.DeleteOneID(t.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *TranClient) DeleteOneID(id uint32) *TranDeleteOne {
	builder := c.Delete().Where(tran.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TranDeleteOne{builder}
}

// Query returns a query builder for Tran.
func (c *TranClient) Query() *TranQuery {
	return &TranQuery{
		config: c.config,
	}
}

// Get returns a Tran entity by its id.
func (c *TranClient) Get(ctx context.Context, id uint32) (*Tran, error) {
	return c.Query().Where(tran.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *TranClient) GetX(ctx context.Context, id uint32) *Tran {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// Hooks returns the client hooks.
func (c *TranClient) Hooks() []Hook {
	hooks := c.hooks.Tran
	return append(hooks[:len(hooks):len(hooks)], tran.Hooks[:]...)
}