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

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"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/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/entql"
	"entgo.io/ent/schema/field"
)

// schemaGraph holds a representation of ent/schema at runtime.
var schemaGraph = func() *sqlgraph.Schema {
	graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 19)}
	graph.Nodes[0] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   appcoin.Table,
			Columns: appcoin.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: appcoin.FieldID,
			},
		},
		Type: "AppCoin",
		Fields: map[string]*sqlgraph.FieldSpec{
			appcoin.FieldCreatedAt:                {Type: field.TypeUint32, Column: appcoin.FieldCreatedAt},
			appcoin.FieldUpdatedAt:                {Type: field.TypeUint32, Column: appcoin.FieldUpdatedAt},
			appcoin.FieldDeletedAt:                {Type: field.TypeUint32, Column: appcoin.FieldDeletedAt},
			appcoin.FieldEntID:                    {Type: field.TypeUUID, Column: appcoin.FieldEntID},
			appcoin.FieldAppID:                    {Type: field.TypeUUID, Column: appcoin.FieldAppID},
			appcoin.FieldCoinTypeID:               {Type: field.TypeUUID, Column: appcoin.FieldCoinTypeID},
			appcoin.FieldName:                     {Type: field.TypeString, Column: appcoin.FieldName},
			appcoin.FieldDisplayNames:             {Type: field.TypeJSON, Column: appcoin.FieldDisplayNames},
			appcoin.FieldLogo:                     {Type: field.TypeString, Column: appcoin.FieldLogo},
			appcoin.FieldForPay:                   {Type: field.TypeBool, Column: appcoin.FieldForPay},
			appcoin.FieldWithdrawAutoReviewAmount: {Type: field.TypeOther, Column: appcoin.FieldWithdrawAutoReviewAmount},
			appcoin.FieldProductPage:              {Type: field.TypeString, Column: appcoin.FieldProductPage},
			appcoin.FieldDisabled:                 {Type: field.TypeBool, Column: appcoin.FieldDisabled},
			appcoin.FieldDailyRewardAmount:        {Type: field.TypeOther, Column: appcoin.FieldDailyRewardAmount},
			appcoin.FieldDisplay:                  {Type: field.TypeBool, Column: appcoin.FieldDisplay},
			appcoin.FieldDisplayIndex:             {Type: field.TypeUint32, Column: appcoin.FieldDisplayIndex},
			appcoin.FieldMaxAmountPerWithdraw:     {Type: field.TypeOther, Column: appcoin.FieldMaxAmountPerWithdraw},
		},
	}
	graph.Nodes[1] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   chainbase.Table,
			Columns: chainbase.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: chainbase.FieldID,
			},
		},
		Type: "ChainBase",
		Fields: map[string]*sqlgraph.FieldSpec{
			chainbase.FieldCreatedAt:  {Type: field.TypeUint32, Column: chainbase.FieldCreatedAt},
			chainbase.FieldUpdatedAt:  {Type: field.TypeUint32, Column: chainbase.FieldUpdatedAt},
			chainbase.FieldDeletedAt:  {Type: field.TypeUint32, Column: chainbase.FieldDeletedAt},
			chainbase.FieldEntID:      {Type: field.TypeUUID, Column: chainbase.FieldEntID},
			chainbase.FieldName:       {Type: field.TypeString, Column: chainbase.FieldName},
			chainbase.FieldLogo:       {Type: field.TypeString, Column: chainbase.FieldLogo},
			chainbase.FieldNativeUnit: {Type: field.TypeString, Column: chainbase.FieldNativeUnit},
			chainbase.FieldAtomicUnit: {Type: field.TypeString, Column: chainbase.FieldAtomicUnit},
			chainbase.FieldUnitExp:    {Type: field.TypeUint32, Column: chainbase.FieldUnitExp},
			chainbase.FieldEnv:        {Type: field.TypeString, Column: chainbase.FieldEnv},
			chainbase.FieldChainID:    {Type: field.TypeString, Column: chainbase.FieldChainID},
			chainbase.FieldNickname:   {Type: field.TypeString, Column: chainbase.FieldNickname},
			chainbase.FieldGasType:    {Type: field.TypeString, Column: chainbase.FieldGasType},
		},
	}
	graph.Nodes[2] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinbase.Table,
			Columns: coinbase.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinbase.FieldID,
			},
		},
		Type: "CoinBase",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinbase.FieldCreatedAt:      {Type: field.TypeUint32, Column: coinbase.FieldCreatedAt},
			coinbase.FieldUpdatedAt:      {Type: field.TypeUint32, Column: coinbase.FieldUpdatedAt},
			coinbase.FieldDeletedAt:      {Type: field.TypeUint32, Column: coinbase.FieldDeletedAt},
			coinbase.FieldEntID:          {Type: field.TypeUUID, Column: coinbase.FieldEntID},
			coinbase.FieldName:           {Type: field.TypeString, Column: coinbase.FieldName},
			coinbase.FieldLogo:           {Type: field.TypeString, Column: coinbase.FieldLogo},
			coinbase.FieldPresale:        {Type: field.TypeBool, Column: coinbase.FieldPresale},
			coinbase.FieldUnit:           {Type: field.TypeString, Column: coinbase.FieldUnit},
			coinbase.FieldEnv:            {Type: field.TypeString, Column: coinbase.FieldEnv},
			coinbase.FieldReservedAmount: {Type: field.TypeOther, Column: coinbase.FieldReservedAmount},
			coinbase.FieldForPay:         {Type: field.TypeBool, Column: coinbase.FieldForPay},
			coinbase.FieldDisabled:       {Type: field.TypeBool, Column: coinbase.FieldDisabled},
		},
	}
	graph.Nodes[3] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coindescription.Table,
			Columns: coindescription.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coindescription.FieldID,
			},
		},
		Type: "CoinDescription",
		Fields: map[string]*sqlgraph.FieldSpec{
			coindescription.FieldCreatedAt:  {Type: field.TypeUint32, Column: coindescription.FieldCreatedAt},
			coindescription.FieldUpdatedAt:  {Type: field.TypeUint32, Column: coindescription.FieldUpdatedAt},
			coindescription.FieldDeletedAt:  {Type: field.TypeUint32, Column: coindescription.FieldDeletedAt},
			coindescription.FieldEntID:      {Type: field.TypeUUID, Column: coindescription.FieldEntID},
			coindescription.FieldAppID:      {Type: field.TypeUUID, Column: coindescription.FieldAppID},
			coindescription.FieldCoinTypeID: {Type: field.TypeUUID, Column: coindescription.FieldCoinTypeID},
			coindescription.FieldUsedFor:    {Type: field.TypeString, Column: coindescription.FieldUsedFor},
			coindescription.FieldTitle:      {Type: field.TypeString, Column: coindescription.FieldTitle},
			coindescription.FieldMessage:    {Type: field.TypeString, Column: coindescription.FieldMessage},
		},
	}
	graph.Nodes[4] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinextra.Table,
			Columns: coinextra.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinextra.FieldID,
			},
		},
		Type: "CoinExtra",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinextra.FieldCreatedAt:  {Type: field.TypeUint32, Column: coinextra.FieldCreatedAt},
			coinextra.FieldUpdatedAt:  {Type: field.TypeUint32, Column: coinextra.FieldUpdatedAt},
			coinextra.FieldDeletedAt:  {Type: field.TypeUint32, Column: coinextra.FieldDeletedAt},
			coinextra.FieldEntID:      {Type: field.TypeUUID, Column: coinextra.FieldEntID},
			coinextra.FieldCoinTypeID: {Type: field.TypeUUID, Column: coinextra.FieldCoinTypeID},
			coinextra.FieldHomePage:   {Type: field.TypeString, Column: coinextra.FieldHomePage},
			coinextra.FieldSpecs:      {Type: field.TypeString, Column: coinextra.FieldSpecs},
			coinextra.FieldStableUsd:  {Type: field.TypeBool, Column: coinextra.FieldStableUsd},
		},
	}
	graph.Nodes[5] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinfiat.Table,
			Columns: coinfiat.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinfiat.FieldID,
			},
		},
		Type: "CoinFiat",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinfiat.FieldCreatedAt:  {Type: field.TypeUint32, Column: coinfiat.FieldCreatedAt},
			coinfiat.FieldUpdatedAt:  {Type: field.TypeUint32, Column: coinfiat.FieldUpdatedAt},
			coinfiat.FieldDeletedAt:  {Type: field.TypeUint32, Column: coinfiat.FieldDeletedAt},
			coinfiat.FieldEntID:      {Type: field.TypeUUID, Column: coinfiat.FieldEntID},
			coinfiat.FieldCoinTypeID: {Type: field.TypeUUID, Column: coinfiat.FieldCoinTypeID},
			coinfiat.FieldFiatID:     {Type: field.TypeUUID, Column: coinfiat.FieldFiatID},
			coinfiat.FieldFeedType:   {Type: field.TypeString, Column: coinfiat.FieldFeedType},
		},
	}
	graph.Nodes[6] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinfiatcurrency.Table,
			Columns: coinfiatcurrency.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinfiatcurrency.FieldID,
			},
		},
		Type: "CoinFiatCurrency",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinfiatcurrency.FieldCreatedAt:       {Type: field.TypeUint32, Column: coinfiatcurrency.FieldCreatedAt},
			coinfiatcurrency.FieldUpdatedAt:       {Type: field.TypeUint32, Column: coinfiatcurrency.FieldUpdatedAt},
			coinfiatcurrency.FieldDeletedAt:       {Type: field.TypeUint32, Column: coinfiatcurrency.FieldDeletedAt},
			coinfiatcurrency.FieldEntID:           {Type: field.TypeUUID, Column: coinfiatcurrency.FieldEntID},
			coinfiatcurrency.FieldCoinTypeID:      {Type: field.TypeUUID, Column: coinfiatcurrency.FieldCoinTypeID},
			coinfiatcurrency.FieldFiatID:          {Type: field.TypeUUID, Column: coinfiatcurrency.FieldFiatID},
			coinfiatcurrency.FieldFeedType:        {Type: field.TypeString, Column: coinfiatcurrency.FieldFeedType},
			coinfiatcurrency.FieldMarketValueLow:  {Type: field.TypeOther, Column: coinfiatcurrency.FieldMarketValueLow},
			coinfiatcurrency.FieldMarketValueHigh: {Type: field.TypeOther, Column: coinfiatcurrency.FieldMarketValueHigh},
		},
	}
	graph.Nodes[7] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinfiatcurrencyhistory.Table,
			Columns: coinfiatcurrencyhistory.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinfiatcurrencyhistory.FieldID,
			},
		},
		Type: "CoinFiatCurrencyHistory",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinfiatcurrencyhistory.FieldCreatedAt:       {Type: field.TypeUint32, Column: coinfiatcurrencyhistory.FieldCreatedAt},
			coinfiatcurrencyhistory.FieldUpdatedAt:       {Type: field.TypeUint32, Column: coinfiatcurrencyhistory.FieldUpdatedAt},
			coinfiatcurrencyhistory.FieldDeletedAt:       {Type: field.TypeUint32, Column: coinfiatcurrencyhistory.FieldDeletedAt},
			coinfiatcurrencyhistory.FieldEntID:           {Type: field.TypeUUID, Column: coinfiatcurrencyhistory.FieldEntID},
			coinfiatcurrencyhistory.FieldCoinTypeID:      {Type: field.TypeUUID, Column: coinfiatcurrencyhistory.FieldCoinTypeID},
			coinfiatcurrencyhistory.FieldFiatID:          {Type: field.TypeUUID, Column: coinfiatcurrencyhistory.FieldFiatID},
			coinfiatcurrencyhistory.FieldFeedType:        {Type: field.TypeString, Column: coinfiatcurrencyhistory.FieldFeedType},
			coinfiatcurrencyhistory.FieldMarketValueLow:  {Type: field.TypeOther, Column: coinfiatcurrencyhistory.FieldMarketValueLow},
			coinfiatcurrencyhistory.FieldMarketValueHigh: {Type: field.TypeOther, Column: coinfiatcurrencyhistory.FieldMarketValueHigh},
		},
	}
	graph.Nodes[8] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   coinusedfor.Table,
			Columns: coinusedfor.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinusedfor.FieldID,
			},
		},
		Type: "CoinUsedFor",
		Fields: map[string]*sqlgraph.FieldSpec{
			coinusedfor.FieldCreatedAt:  {Type: field.TypeUint32, Column: coinusedfor.FieldCreatedAt},
			coinusedfor.FieldUpdatedAt:  {Type: field.TypeUint32, Column: coinusedfor.FieldUpdatedAt},
			coinusedfor.FieldDeletedAt:  {Type: field.TypeUint32, Column: coinusedfor.FieldDeletedAt},
			coinusedfor.FieldEntID:      {Type: field.TypeUUID, Column: coinusedfor.FieldEntID},
			coinusedfor.FieldCoinTypeID: {Type: field.TypeUUID, Column: coinusedfor.FieldCoinTypeID},
			coinusedfor.FieldUsedFor:    {Type: field.TypeString, Column: coinusedfor.FieldUsedFor},
			coinusedfor.FieldPriority:   {Type: field.TypeUint32, Column: coinusedfor.FieldPriority},
		},
	}
	graph.Nodes[9] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   currency.Table,
			Columns: currency.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: currency.FieldID,
			},
		},
		Type: "Currency",
		Fields: map[string]*sqlgraph.FieldSpec{
			currency.FieldCreatedAt:       {Type: field.TypeUint32, Column: currency.FieldCreatedAt},
			currency.FieldUpdatedAt:       {Type: field.TypeUint32, Column: currency.FieldUpdatedAt},
			currency.FieldDeletedAt:       {Type: field.TypeUint32, Column: currency.FieldDeletedAt},
			currency.FieldEntID:           {Type: field.TypeUUID, Column: currency.FieldEntID},
			currency.FieldCoinTypeID:      {Type: field.TypeUUID, Column: currency.FieldCoinTypeID},
			currency.FieldFeedType:        {Type: field.TypeString, Column: currency.FieldFeedType},
			currency.FieldMarketValueHigh: {Type: field.TypeOther, Column: currency.FieldMarketValueHigh},
			currency.FieldMarketValueLow:  {Type: field.TypeOther, Column: currency.FieldMarketValueLow},
		},
	}
	graph.Nodes[10] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   currencyfeed.Table,
			Columns: currencyfeed.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: currencyfeed.FieldID,
			},
		},
		Type: "CurrencyFeed",
		Fields: map[string]*sqlgraph.FieldSpec{
			currencyfeed.FieldCreatedAt:    {Type: field.TypeUint32, Column: currencyfeed.FieldCreatedAt},
			currencyfeed.FieldUpdatedAt:    {Type: field.TypeUint32, Column: currencyfeed.FieldUpdatedAt},
			currencyfeed.FieldDeletedAt:    {Type: field.TypeUint32, Column: currencyfeed.FieldDeletedAt},
			currencyfeed.FieldEntID:        {Type: field.TypeUUID, Column: currencyfeed.FieldEntID},
			currencyfeed.FieldCoinTypeID:   {Type: field.TypeUUID, Column: currencyfeed.FieldCoinTypeID},
			currencyfeed.FieldFeedType:     {Type: field.TypeString, Column: currencyfeed.FieldFeedType},
			currencyfeed.FieldFeedCoinName: {Type: field.TypeString, Column: currencyfeed.FieldFeedCoinName},
			currencyfeed.FieldDisabled:     {Type: field.TypeBool, Column: currencyfeed.FieldDisabled},
		},
	}
	graph.Nodes[11] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   currencyhistory.Table,
			Columns: currencyhistory.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: currencyhistory.FieldID,
			},
		},
		Type: "CurrencyHistory",
		Fields: map[string]*sqlgraph.FieldSpec{
			currencyhistory.FieldCreatedAt:       {Type: field.TypeUint32, Column: currencyhistory.FieldCreatedAt},
			currencyhistory.FieldUpdatedAt:       {Type: field.TypeUint32, Column: currencyhistory.FieldUpdatedAt},
			currencyhistory.FieldDeletedAt:       {Type: field.TypeUint32, Column: currencyhistory.FieldDeletedAt},
			currencyhistory.FieldEntID:           {Type: field.TypeUUID, Column: currencyhistory.FieldEntID},
			currencyhistory.FieldCoinTypeID:      {Type: field.TypeUUID, Column: currencyhistory.FieldCoinTypeID},
			currencyhistory.FieldFeedType:        {Type: field.TypeString, Column: currencyhistory.FieldFeedType},
			currencyhistory.FieldMarketValueHigh: {Type: field.TypeOther, Column: currencyhistory.FieldMarketValueHigh},
			currencyhistory.FieldMarketValueLow:  {Type: field.TypeOther, Column: currencyhistory.FieldMarketValueLow},
		},
	}
	graph.Nodes[12] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   exchangerate.Table,
			Columns: exchangerate.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: exchangerate.FieldID,
			},
		},
		Type: "ExchangeRate",
		Fields: map[string]*sqlgraph.FieldSpec{
			exchangerate.FieldCreatedAt:     {Type: field.TypeUint32, Column: exchangerate.FieldCreatedAt},
			exchangerate.FieldUpdatedAt:     {Type: field.TypeUint32, Column: exchangerate.FieldUpdatedAt},
			exchangerate.FieldDeletedAt:     {Type: field.TypeUint32, Column: exchangerate.FieldDeletedAt},
			exchangerate.FieldEntID:         {Type: field.TypeUUID, Column: exchangerate.FieldEntID},
			exchangerate.FieldAppID:         {Type: field.TypeUUID, Column: exchangerate.FieldAppID},
			exchangerate.FieldCoinTypeID:    {Type: field.TypeUUID, Column: exchangerate.FieldCoinTypeID},
			exchangerate.FieldMarketValue:   {Type: field.TypeOther, Column: exchangerate.FieldMarketValue},
			exchangerate.FieldSettleValue:   {Type: field.TypeOther, Column: exchangerate.FieldSettleValue},
			exchangerate.FieldSettlePercent: {Type: field.TypeUint32, Column: exchangerate.FieldSettlePercent},
			exchangerate.FieldSettleTips:    {Type: field.TypeJSON, Column: exchangerate.FieldSettleTips},
			exchangerate.FieldSetter:        {Type: field.TypeUUID, Column: exchangerate.FieldSetter},
		},
	}
	graph.Nodes[13] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   fiat.Table,
			Columns: fiat.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: fiat.FieldID,
			},
		},
		Type: "Fiat",
		Fields: map[string]*sqlgraph.FieldSpec{
			fiat.FieldCreatedAt: {Type: field.TypeUint32, Column: fiat.FieldCreatedAt},
			fiat.FieldUpdatedAt: {Type: field.TypeUint32, Column: fiat.FieldUpdatedAt},
			fiat.FieldDeletedAt: {Type: field.TypeUint32, Column: fiat.FieldDeletedAt},
			fiat.FieldEntID:     {Type: field.TypeUUID, Column: fiat.FieldEntID},
			fiat.FieldName:      {Type: field.TypeString, Column: fiat.FieldName},
			fiat.FieldLogo:      {Type: field.TypeString, Column: fiat.FieldLogo},
			fiat.FieldUnit:      {Type: field.TypeString, Column: fiat.FieldUnit},
		},
	}
	graph.Nodes[14] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   fiatcurrency.Table,
			Columns: fiatcurrency.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: fiatcurrency.FieldID,
			},
		},
		Type: "FiatCurrency",
		Fields: map[string]*sqlgraph.FieldSpec{
			fiatcurrency.FieldCreatedAt:       {Type: field.TypeUint32, Column: fiatcurrency.FieldCreatedAt},
			fiatcurrency.FieldUpdatedAt:       {Type: field.TypeUint32, Column: fiatcurrency.FieldUpdatedAt},
			fiatcurrency.FieldDeletedAt:       {Type: field.TypeUint32, Column: fiatcurrency.FieldDeletedAt},
			fiatcurrency.FieldEntID:           {Type: field.TypeUUID, Column: fiatcurrency.FieldEntID},
			fiatcurrency.FieldFiatID:          {Type: field.TypeUUID, Column: fiatcurrency.FieldFiatID},
			fiatcurrency.FieldFeedType:        {Type: field.TypeString, Column: fiatcurrency.FieldFeedType},
			fiatcurrency.FieldMarketValueLow:  {Type: field.TypeOther, Column: fiatcurrency.FieldMarketValueLow},
			fiatcurrency.FieldMarketValueHigh: {Type: field.TypeOther, Column: fiatcurrency.FieldMarketValueHigh},
		},
	}
	graph.Nodes[15] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   fiatcurrencyfeed.Table,
			Columns: fiatcurrencyfeed.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: fiatcurrencyfeed.FieldID,
			},
		},
		Type: "FiatCurrencyFeed",
		Fields: map[string]*sqlgraph.FieldSpec{
			fiatcurrencyfeed.FieldCreatedAt:    {Type: field.TypeUint32, Column: fiatcurrencyfeed.FieldCreatedAt},
			fiatcurrencyfeed.FieldUpdatedAt:    {Type: field.TypeUint32, Column: fiatcurrencyfeed.FieldUpdatedAt},
			fiatcurrencyfeed.FieldDeletedAt:    {Type: field.TypeUint32, Column: fiatcurrencyfeed.FieldDeletedAt},
			fiatcurrencyfeed.FieldEntID:        {Type: field.TypeUUID, Column: fiatcurrencyfeed.FieldEntID},
			fiatcurrencyfeed.FieldFiatID:       {Type: field.TypeUUID, Column: fiatcurrencyfeed.FieldFiatID},
			fiatcurrencyfeed.FieldFeedType:     {Type: field.TypeString, Column: fiatcurrencyfeed.FieldFeedType},
			fiatcurrencyfeed.FieldFeedFiatName: {Type: field.TypeString, Column: fiatcurrencyfeed.FieldFeedFiatName},
			fiatcurrencyfeed.FieldDisabled:     {Type: field.TypeBool, Column: fiatcurrencyfeed.FieldDisabled},
		},
	}
	graph.Nodes[16] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   fiatcurrencyhistory.Table,
			Columns: fiatcurrencyhistory.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: fiatcurrencyhistory.FieldID,
			},
		},
		Type: "FiatCurrencyHistory",
		Fields: map[string]*sqlgraph.FieldSpec{
			fiatcurrencyhistory.FieldCreatedAt:       {Type: field.TypeUint32, Column: fiatcurrencyhistory.FieldCreatedAt},
			fiatcurrencyhistory.FieldUpdatedAt:       {Type: field.TypeUint32, Column: fiatcurrencyhistory.FieldUpdatedAt},
			fiatcurrencyhistory.FieldDeletedAt:       {Type: field.TypeUint32, Column: fiatcurrencyhistory.FieldDeletedAt},
			fiatcurrencyhistory.FieldEntID:           {Type: field.TypeUUID, Column: fiatcurrencyhistory.FieldEntID},
			fiatcurrencyhistory.FieldFiatID:          {Type: field.TypeUUID, Column: fiatcurrencyhistory.FieldFiatID},
			fiatcurrencyhistory.FieldFeedType:        {Type: field.TypeString, Column: fiatcurrencyhistory.FieldFeedType},
			fiatcurrencyhistory.FieldMarketValueLow:  {Type: field.TypeOther, Column: fiatcurrencyhistory.FieldMarketValueLow},
			fiatcurrencyhistory.FieldMarketValueHigh: {Type: field.TypeOther, Column: fiatcurrencyhistory.FieldMarketValueHigh},
		},
	}
	graph.Nodes[17] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   setting.Table,
			Columns: setting.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: setting.FieldID,
			},
		},
		Type: "Setting",
		Fields: map[string]*sqlgraph.FieldSpec{
			setting.FieldCreatedAt:                   {Type: field.TypeUint32, Column: setting.FieldCreatedAt},
			setting.FieldUpdatedAt:                   {Type: field.TypeUint32, Column: setting.FieldUpdatedAt},
			setting.FieldDeletedAt:                   {Type: field.TypeUint32, Column: setting.FieldDeletedAt},
			setting.FieldEntID:                       {Type: field.TypeUUID, Column: setting.FieldEntID},
			setting.FieldCoinTypeID:                  {Type: field.TypeUUID, Column: setting.FieldCoinTypeID},
			setting.FieldFeeCoinTypeID:               {Type: field.TypeUUID, Column: setting.FieldFeeCoinTypeID},
			setting.FieldWithdrawFeeByStableUsd:      {Type: field.TypeBool, Column: setting.FieldWithdrawFeeByStableUsd},
			setting.FieldWithdrawFeeAmount:           {Type: field.TypeOther, Column: setting.FieldWithdrawFeeAmount},
			setting.FieldCollectFeeAmount:            {Type: field.TypeOther, Column: setting.FieldCollectFeeAmount},
			setting.FieldHotWalletFeeAmount:          {Type: field.TypeOther, Column: setting.FieldHotWalletFeeAmount},
			setting.FieldLowFeeAmount:                {Type: field.TypeOther, Column: setting.FieldLowFeeAmount},
			setting.FieldHotLowFeeAmount:             {Type: field.TypeOther, Column: setting.FieldHotLowFeeAmount},
			setting.FieldHotWalletAccountAmount:      {Type: field.TypeOther, Column: setting.FieldHotWalletAccountAmount},
			setting.FieldPaymentAccountCollectAmount: {Type: field.TypeOther, Column: setting.FieldPaymentAccountCollectAmount},
			setting.FieldLeastTransferAmount:         {Type: field.TypeOther, Column: setting.FieldLeastTransferAmount},
			setting.FieldNeedMemo:                    {Type: field.TypeBool, Column: setting.FieldNeedMemo},
			setting.FieldRefreshCurrency:             {Type: field.TypeBool, Column: setting.FieldRefreshCurrency},
			setting.FieldCheckNewAddressBalance:      {Type: field.TypeBool, Column: setting.FieldCheckNewAddressBalance},
		},
	}
	graph.Nodes[18] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   tran.Table,
			Columns: tran.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: tran.FieldID,
			},
		},
		Type: "Tran",
		Fields: map[string]*sqlgraph.FieldSpec{
			tran.FieldCreatedAt:     {Type: field.TypeUint32, Column: tran.FieldCreatedAt},
			tran.FieldUpdatedAt:     {Type: field.TypeUint32, Column: tran.FieldUpdatedAt},
			tran.FieldDeletedAt:     {Type: field.TypeUint32, Column: tran.FieldDeletedAt},
			tran.FieldEntID:         {Type: field.TypeUUID, Column: tran.FieldEntID},
			tran.FieldCoinTypeID:    {Type: field.TypeUUID, Column: tran.FieldCoinTypeID},
			tran.FieldFromAccountID: {Type: field.TypeUUID, Column: tran.FieldFromAccountID},
			tran.FieldToAccountID:   {Type: field.TypeUUID, Column: tran.FieldToAccountID},
			tran.FieldAmount:        {Type: field.TypeOther, Column: tran.FieldAmount},
			tran.FieldFeeAmount:     {Type: field.TypeOther, Column: tran.FieldFeeAmount},
			tran.FieldChainTxID:     {Type: field.TypeString, Column: tran.FieldChainTxID},
			tran.FieldState:         {Type: field.TypeString, Column: tran.FieldState},
			tran.FieldExtra:         {Type: field.TypeString, Column: tran.FieldExtra},
			tran.FieldType:          {Type: field.TypeString, Column: tran.FieldType},
		},
	}
	return graph
}()

// predicateAdder wraps the addPredicate method.
// All update, update-one and query builders implement this interface.
type predicateAdder interface {
	addPredicate(func(s *sql.Selector))
}

// addPredicate implements the predicateAdder interface.
func (acq *AppCoinQuery) addPredicate(pred func(s *sql.Selector)) {
	acq.predicates = append(acq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the AppCoinQuery builder.
func (acq *AppCoinQuery) Filter() *AppCoinFilter {
	return &AppCoinFilter{config: acq.config, predicateAdder: acq}
}

// addPredicate implements the predicateAdder interface.
func (m *AppCoinMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the AppCoinMutation builder.
func (m *AppCoinMutation) Filter() *AppCoinFilter {
	return &AppCoinFilter{config: m.config, predicateAdder: m}
}

// AppCoinFilter provides a generic filtering capability at runtime for AppCoinQuery.
type AppCoinFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *AppCoinFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[0].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *AppCoinFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(appcoin.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *AppCoinFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(appcoin.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *AppCoinFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(appcoin.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *AppCoinFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(appcoin.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *AppCoinFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(appcoin.FieldEntID))
}

// WhereAppID applies the entql [16]byte predicate on the app_id field.
func (f *AppCoinFilter) WhereAppID(p entql.ValueP) {
	f.Where(p.Field(appcoin.FieldAppID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *AppCoinFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(appcoin.FieldCoinTypeID))
}

// WhereName applies the entql string predicate on the name field.
func (f *AppCoinFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(appcoin.FieldName))
}

// WhereDisplayNames applies the entql json.RawMessage predicate on the display_names field.
func (f *AppCoinFilter) WhereDisplayNames(p entql.BytesP) {
	f.Where(p.Field(appcoin.FieldDisplayNames))
}

// WhereLogo applies the entql string predicate on the logo field.
func (f *AppCoinFilter) WhereLogo(p entql.StringP) {
	f.Where(p.Field(appcoin.FieldLogo))
}

// WhereForPay applies the entql bool predicate on the for_pay field.
func (f *AppCoinFilter) WhereForPay(p entql.BoolP) {
	f.Where(p.Field(appcoin.FieldForPay))
}

// WhereWithdrawAutoReviewAmount applies the entql other predicate on the withdraw_auto_review_amount field.
func (f *AppCoinFilter) WhereWithdrawAutoReviewAmount(p entql.OtherP) {
	f.Where(p.Field(appcoin.FieldWithdrawAutoReviewAmount))
}

// WhereProductPage applies the entql string predicate on the product_page field.
func (f *AppCoinFilter) WhereProductPage(p entql.StringP) {
	f.Where(p.Field(appcoin.FieldProductPage))
}

// WhereDisabled applies the entql bool predicate on the disabled field.
func (f *AppCoinFilter) WhereDisabled(p entql.BoolP) {
	f.Where(p.Field(appcoin.FieldDisabled))
}

// WhereDailyRewardAmount applies the entql other predicate on the daily_reward_amount field.
func (f *AppCoinFilter) WhereDailyRewardAmount(p entql.OtherP) {
	f.Where(p.Field(appcoin.FieldDailyRewardAmount))
}

// WhereDisplay applies the entql bool predicate on the display field.
func (f *AppCoinFilter) WhereDisplay(p entql.BoolP) {
	f.Where(p.Field(appcoin.FieldDisplay))
}

// WhereDisplayIndex applies the entql uint32 predicate on the display_index field.
func (f *AppCoinFilter) WhereDisplayIndex(p entql.Uint32P) {
	f.Where(p.Field(appcoin.FieldDisplayIndex))
}

// WhereMaxAmountPerWithdraw applies the entql other predicate on the max_amount_per_withdraw field.
func (f *AppCoinFilter) WhereMaxAmountPerWithdraw(p entql.OtherP) {
	f.Where(p.Field(appcoin.FieldMaxAmountPerWithdraw))
}

// addPredicate implements the predicateAdder interface.
func (cbq *ChainBaseQuery) addPredicate(pred func(s *sql.Selector)) {
	cbq.predicates = append(cbq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the ChainBaseQuery builder.
func (cbq *ChainBaseQuery) Filter() *ChainBaseFilter {
	return &ChainBaseFilter{config: cbq.config, predicateAdder: cbq}
}

// addPredicate implements the predicateAdder interface.
func (m *ChainBaseMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the ChainBaseMutation builder.
func (m *ChainBaseMutation) Filter() *ChainBaseFilter {
	return &ChainBaseFilter{config: m.config, predicateAdder: m}
}

// ChainBaseFilter provides a generic filtering capability at runtime for ChainBaseQuery.
type ChainBaseFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *ChainBaseFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[1].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *ChainBaseFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(chainbase.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *ChainBaseFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(chainbase.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *ChainBaseFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(chainbase.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *ChainBaseFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(chainbase.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *ChainBaseFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(chainbase.FieldEntID))
}

// WhereName applies the entql string predicate on the name field.
func (f *ChainBaseFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldName))
}

// WhereLogo applies the entql string predicate on the logo field.
func (f *ChainBaseFilter) WhereLogo(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldLogo))
}

// WhereNativeUnit applies the entql string predicate on the native_unit field.
func (f *ChainBaseFilter) WhereNativeUnit(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldNativeUnit))
}

// WhereAtomicUnit applies the entql string predicate on the atomic_unit field.
func (f *ChainBaseFilter) WhereAtomicUnit(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldAtomicUnit))
}

// WhereUnitExp applies the entql uint32 predicate on the unit_exp field.
func (f *ChainBaseFilter) WhereUnitExp(p entql.Uint32P) {
	f.Where(p.Field(chainbase.FieldUnitExp))
}

// WhereEnv applies the entql string predicate on the env field.
func (f *ChainBaseFilter) WhereEnv(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldEnv))
}

// WhereChainID applies the entql string predicate on the chain_id field.
func (f *ChainBaseFilter) WhereChainID(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldChainID))
}

// WhereNickname applies the entql string predicate on the nickname field.
func (f *ChainBaseFilter) WhereNickname(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldNickname))
}

// WhereGasType applies the entql string predicate on the gas_type field.
func (f *ChainBaseFilter) WhereGasType(p entql.StringP) {
	f.Where(p.Field(chainbase.FieldGasType))
}

// addPredicate implements the predicateAdder interface.
func (cbq *CoinBaseQuery) addPredicate(pred func(s *sql.Selector)) {
	cbq.predicates = append(cbq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinBaseQuery builder.
func (cbq *CoinBaseQuery) Filter() *CoinBaseFilter {
	return &CoinBaseFilter{config: cbq.config, predicateAdder: cbq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinBaseMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinBaseMutation builder.
func (m *CoinBaseMutation) Filter() *CoinBaseFilter {
	return &CoinBaseFilter{config: m.config, predicateAdder: m}
}

// CoinBaseFilter provides a generic filtering capability at runtime for CoinBaseQuery.
type CoinBaseFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinBaseFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[2].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinBaseFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinbase.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinBaseFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinbase.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinBaseFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinbase.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinBaseFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinbase.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinBaseFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinbase.FieldEntID))
}

// WhereName applies the entql string predicate on the name field.
func (f *CoinBaseFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(coinbase.FieldName))
}

// WhereLogo applies the entql string predicate on the logo field.
func (f *CoinBaseFilter) WhereLogo(p entql.StringP) {
	f.Where(p.Field(coinbase.FieldLogo))
}

// WherePresale applies the entql bool predicate on the presale field.
func (f *CoinBaseFilter) WherePresale(p entql.BoolP) {
	f.Where(p.Field(coinbase.FieldPresale))
}

// WhereUnit applies the entql string predicate on the unit field.
func (f *CoinBaseFilter) WhereUnit(p entql.StringP) {
	f.Where(p.Field(coinbase.FieldUnit))
}

// WhereEnv applies the entql string predicate on the env field.
func (f *CoinBaseFilter) WhereEnv(p entql.StringP) {
	f.Where(p.Field(coinbase.FieldEnv))
}

// WhereReservedAmount applies the entql other predicate on the reserved_amount field.
func (f *CoinBaseFilter) WhereReservedAmount(p entql.OtherP) {
	f.Where(p.Field(coinbase.FieldReservedAmount))
}

// WhereForPay applies the entql bool predicate on the for_pay field.
func (f *CoinBaseFilter) WhereForPay(p entql.BoolP) {
	f.Where(p.Field(coinbase.FieldForPay))
}

// WhereDisabled applies the entql bool predicate on the disabled field.
func (f *CoinBaseFilter) WhereDisabled(p entql.BoolP) {
	f.Where(p.Field(coinbase.FieldDisabled))
}

// addPredicate implements the predicateAdder interface.
func (cdq *CoinDescriptionQuery) addPredicate(pred func(s *sql.Selector)) {
	cdq.predicates = append(cdq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinDescriptionQuery builder.
func (cdq *CoinDescriptionQuery) Filter() *CoinDescriptionFilter {
	return &CoinDescriptionFilter{config: cdq.config, predicateAdder: cdq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinDescriptionMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinDescriptionMutation builder.
func (m *CoinDescriptionMutation) Filter() *CoinDescriptionFilter {
	return &CoinDescriptionFilter{config: m.config, predicateAdder: m}
}

// CoinDescriptionFilter provides a generic filtering capability at runtime for CoinDescriptionQuery.
type CoinDescriptionFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinDescriptionFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[3].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinDescriptionFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coindescription.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinDescriptionFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coindescription.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinDescriptionFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coindescription.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinDescriptionFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coindescription.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinDescriptionFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coindescription.FieldEntID))
}

// WhereAppID applies the entql [16]byte predicate on the app_id field.
func (f *CoinDescriptionFilter) WhereAppID(p entql.ValueP) {
	f.Where(p.Field(coindescription.FieldAppID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinDescriptionFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coindescription.FieldCoinTypeID))
}

// WhereUsedFor applies the entql string predicate on the used_for field.
func (f *CoinDescriptionFilter) WhereUsedFor(p entql.StringP) {
	f.Where(p.Field(coindescription.FieldUsedFor))
}

// WhereTitle applies the entql string predicate on the title field.
func (f *CoinDescriptionFilter) WhereTitle(p entql.StringP) {
	f.Where(p.Field(coindescription.FieldTitle))
}

// WhereMessage applies the entql string predicate on the message field.
func (f *CoinDescriptionFilter) WhereMessage(p entql.StringP) {
	f.Where(p.Field(coindescription.FieldMessage))
}

// addPredicate implements the predicateAdder interface.
func (ceq *CoinExtraQuery) addPredicate(pred func(s *sql.Selector)) {
	ceq.predicates = append(ceq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinExtraQuery builder.
func (ceq *CoinExtraQuery) Filter() *CoinExtraFilter {
	return &CoinExtraFilter{config: ceq.config, predicateAdder: ceq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinExtraMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinExtraMutation builder.
func (m *CoinExtraMutation) Filter() *CoinExtraFilter {
	return &CoinExtraFilter{config: m.config, predicateAdder: m}
}

// CoinExtraFilter provides a generic filtering capability at runtime for CoinExtraQuery.
type CoinExtraFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinExtraFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[4].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinExtraFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinextra.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinExtraFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinextra.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinExtraFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinextra.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinExtraFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinextra.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinExtraFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinextra.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinExtraFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coinextra.FieldCoinTypeID))
}

// WhereHomePage applies the entql string predicate on the home_page field.
func (f *CoinExtraFilter) WhereHomePage(p entql.StringP) {
	f.Where(p.Field(coinextra.FieldHomePage))
}

// WhereSpecs applies the entql string predicate on the specs field.
func (f *CoinExtraFilter) WhereSpecs(p entql.StringP) {
	f.Where(p.Field(coinextra.FieldSpecs))
}

// WhereStableUsd applies the entql bool predicate on the stable_usd field.
func (f *CoinExtraFilter) WhereStableUsd(p entql.BoolP) {
	f.Where(p.Field(coinextra.FieldStableUsd))
}

// addPredicate implements the predicateAdder interface.
func (cfq *CoinFiatQuery) addPredicate(pred func(s *sql.Selector)) {
	cfq.predicates = append(cfq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinFiatQuery builder.
func (cfq *CoinFiatQuery) Filter() *CoinFiatFilter {
	return &CoinFiatFilter{config: cfq.config, predicateAdder: cfq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinFiatMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinFiatMutation builder.
func (m *CoinFiatMutation) Filter() *CoinFiatFilter {
	return &CoinFiatFilter{config: m.config, predicateAdder: m}
}

// CoinFiatFilter provides a generic filtering capability at runtime for CoinFiatQuery.
type CoinFiatFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinFiatFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[5].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinFiatFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinfiat.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinFiatFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiat.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinFiatFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiat.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinFiatFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiat.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinFiatFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinfiat.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinFiatFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coinfiat.FieldCoinTypeID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *CoinFiatFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(coinfiat.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CoinFiatFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(coinfiat.FieldFeedType))
}

// addPredicate implements the predicateAdder interface.
func (cfcq *CoinFiatCurrencyQuery) addPredicate(pred func(s *sql.Selector)) {
	cfcq.predicates = append(cfcq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinFiatCurrencyQuery builder.
func (cfcq *CoinFiatCurrencyQuery) Filter() *CoinFiatCurrencyFilter {
	return &CoinFiatCurrencyFilter{config: cfcq.config, predicateAdder: cfcq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinFiatCurrencyMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinFiatCurrencyMutation builder.
func (m *CoinFiatCurrencyMutation) Filter() *CoinFiatCurrencyFilter {
	return &CoinFiatCurrencyFilter{config: m.config, predicateAdder: m}
}

// CoinFiatCurrencyFilter provides a generic filtering capability at runtime for CoinFiatCurrencyQuery.
type CoinFiatCurrencyFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinFiatCurrencyFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[6].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinFiatCurrencyFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrency.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinFiatCurrencyFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrency.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinFiatCurrencyFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrency.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinFiatCurrencyFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrency.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinFiatCurrencyFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrency.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinFiatCurrencyFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrency.FieldCoinTypeID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *CoinFiatCurrencyFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrency.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CoinFiatCurrencyFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(coinfiatcurrency.FieldFeedType))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *CoinFiatCurrencyFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(coinfiatcurrency.FieldMarketValueLow))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *CoinFiatCurrencyFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(coinfiatcurrency.FieldMarketValueHigh))
}

// addPredicate implements the predicateAdder interface.
func (cfchq *CoinFiatCurrencyHistoryQuery) addPredicate(pred func(s *sql.Selector)) {
	cfchq.predicates = append(cfchq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinFiatCurrencyHistoryQuery builder.
func (cfchq *CoinFiatCurrencyHistoryQuery) Filter() *CoinFiatCurrencyHistoryFilter {
	return &CoinFiatCurrencyHistoryFilter{config: cfchq.config, predicateAdder: cfchq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinFiatCurrencyHistoryMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinFiatCurrencyHistoryMutation builder.
func (m *CoinFiatCurrencyHistoryMutation) Filter() *CoinFiatCurrencyHistoryFilter {
	return &CoinFiatCurrencyHistoryFilter{config: m.config, predicateAdder: m}
}

// CoinFiatCurrencyHistoryFilter provides a generic filtering capability at runtime for CoinFiatCurrencyHistoryQuery.
type CoinFiatCurrencyHistoryFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinFiatCurrencyHistoryFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[7].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinFiatCurrencyHistoryFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinFiatCurrencyHistoryFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinFiatCurrencyHistoryFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinFiatCurrencyHistoryFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinFiatCurrencyHistoryFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinFiatCurrencyHistoryFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldCoinTypeID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *CoinFiatCurrencyHistoryFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CoinFiatCurrencyHistoryFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldFeedType))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *CoinFiatCurrencyHistoryFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldMarketValueLow))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *CoinFiatCurrencyHistoryFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(coinfiatcurrencyhistory.FieldMarketValueHigh))
}

// addPredicate implements the predicateAdder interface.
func (cufq *CoinUsedForQuery) addPredicate(pred func(s *sql.Selector)) {
	cufq.predicates = append(cufq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CoinUsedForQuery builder.
func (cufq *CoinUsedForQuery) Filter() *CoinUsedForFilter {
	return &CoinUsedForFilter{config: cufq.config, predicateAdder: cufq}
}

// addPredicate implements the predicateAdder interface.
func (m *CoinUsedForMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CoinUsedForMutation builder.
func (m *CoinUsedForMutation) Filter() *CoinUsedForFilter {
	return &CoinUsedForFilter{config: m.config, predicateAdder: m}
}

// CoinUsedForFilter provides a generic filtering capability at runtime for CoinUsedForQuery.
type CoinUsedForFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CoinUsedForFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[8].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CoinUsedForFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(coinusedfor.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CoinUsedForFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinusedfor.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CoinUsedForFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(coinusedfor.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CoinUsedForFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(coinusedfor.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CoinUsedForFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(coinusedfor.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CoinUsedForFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(coinusedfor.FieldCoinTypeID))
}

// WhereUsedFor applies the entql string predicate on the used_for field.
func (f *CoinUsedForFilter) WhereUsedFor(p entql.StringP) {
	f.Where(p.Field(coinusedfor.FieldUsedFor))
}

// WherePriority applies the entql uint32 predicate on the priority field.
func (f *CoinUsedForFilter) WherePriority(p entql.Uint32P) {
	f.Where(p.Field(coinusedfor.FieldPriority))
}

// addPredicate implements the predicateAdder interface.
func (cq *CurrencyQuery) addPredicate(pred func(s *sql.Selector)) {
	cq.predicates = append(cq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CurrencyQuery builder.
func (cq *CurrencyQuery) Filter() *CurrencyFilter {
	return &CurrencyFilter{config: cq.config, predicateAdder: cq}
}

// addPredicate implements the predicateAdder interface.
func (m *CurrencyMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CurrencyMutation builder.
func (m *CurrencyMutation) Filter() *CurrencyFilter {
	return &CurrencyFilter{config: m.config, predicateAdder: m}
}

// CurrencyFilter provides a generic filtering capability at runtime for CurrencyQuery.
type CurrencyFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CurrencyFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[9].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CurrencyFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(currency.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CurrencyFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(currency.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CurrencyFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(currency.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CurrencyFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(currency.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CurrencyFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(currency.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CurrencyFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(currency.FieldCoinTypeID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CurrencyFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(currency.FieldFeedType))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *CurrencyFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(currency.FieldMarketValueHigh))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *CurrencyFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(currency.FieldMarketValueLow))
}

// addPredicate implements the predicateAdder interface.
func (cfq *CurrencyFeedQuery) addPredicate(pred func(s *sql.Selector)) {
	cfq.predicates = append(cfq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CurrencyFeedQuery builder.
func (cfq *CurrencyFeedQuery) Filter() *CurrencyFeedFilter {
	return &CurrencyFeedFilter{config: cfq.config, predicateAdder: cfq}
}

// addPredicate implements the predicateAdder interface.
func (m *CurrencyFeedMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CurrencyFeedMutation builder.
func (m *CurrencyFeedMutation) Filter() *CurrencyFeedFilter {
	return &CurrencyFeedFilter{config: m.config, predicateAdder: m}
}

// CurrencyFeedFilter provides a generic filtering capability at runtime for CurrencyFeedQuery.
type CurrencyFeedFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CurrencyFeedFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[10].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CurrencyFeedFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(currencyfeed.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CurrencyFeedFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyfeed.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CurrencyFeedFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyfeed.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CurrencyFeedFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyfeed.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CurrencyFeedFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(currencyfeed.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CurrencyFeedFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(currencyfeed.FieldCoinTypeID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CurrencyFeedFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(currencyfeed.FieldFeedType))
}

// WhereFeedCoinName applies the entql string predicate on the feed_coin_name field.
func (f *CurrencyFeedFilter) WhereFeedCoinName(p entql.StringP) {
	f.Where(p.Field(currencyfeed.FieldFeedCoinName))
}

// WhereDisabled applies the entql bool predicate on the disabled field.
func (f *CurrencyFeedFilter) WhereDisabled(p entql.BoolP) {
	f.Where(p.Field(currencyfeed.FieldDisabled))
}

// addPredicate implements the predicateAdder interface.
func (chq *CurrencyHistoryQuery) addPredicate(pred func(s *sql.Selector)) {
	chq.predicates = append(chq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CurrencyHistoryQuery builder.
func (chq *CurrencyHistoryQuery) Filter() *CurrencyHistoryFilter {
	return &CurrencyHistoryFilter{config: chq.config, predicateAdder: chq}
}

// addPredicate implements the predicateAdder interface.
func (m *CurrencyHistoryMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CurrencyHistoryMutation builder.
func (m *CurrencyHistoryMutation) Filter() *CurrencyHistoryFilter {
	return &CurrencyHistoryFilter{config: m.config, predicateAdder: m}
}

// CurrencyHistoryFilter provides a generic filtering capability at runtime for CurrencyHistoryQuery.
type CurrencyHistoryFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *CurrencyHistoryFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[11].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *CurrencyHistoryFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(currencyhistory.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *CurrencyHistoryFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyhistory.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *CurrencyHistoryFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyhistory.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *CurrencyHistoryFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(currencyhistory.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *CurrencyHistoryFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(currencyhistory.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *CurrencyHistoryFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(currencyhistory.FieldCoinTypeID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *CurrencyHistoryFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(currencyhistory.FieldFeedType))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *CurrencyHistoryFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(currencyhistory.FieldMarketValueHigh))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *CurrencyHistoryFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(currencyhistory.FieldMarketValueLow))
}

// addPredicate implements the predicateAdder interface.
func (erq *ExchangeRateQuery) addPredicate(pred func(s *sql.Selector)) {
	erq.predicates = append(erq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the ExchangeRateQuery builder.
func (erq *ExchangeRateQuery) Filter() *ExchangeRateFilter {
	return &ExchangeRateFilter{config: erq.config, predicateAdder: erq}
}

// addPredicate implements the predicateAdder interface.
func (m *ExchangeRateMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the ExchangeRateMutation builder.
func (m *ExchangeRateMutation) Filter() *ExchangeRateFilter {
	return &ExchangeRateFilter{config: m.config, predicateAdder: m}
}

// ExchangeRateFilter provides a generic filtering capability at runtime for ExchangeRateQuery.
type ExchangeRateFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *ExchangeRateFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[12].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *ExchangeRateFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(exchangerate.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *ExchangeRateFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(exchangerate.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *ExchangeRateFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(exchangerate.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *ExchangeRateFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(exchangerate.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *ExchangeRateFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(exchangerate.FieldEntID))
}

// WhereAppID applies the entql [16]byte predicate on the app_id field.
func (f *ExchangeRateFilter) WhereAppID(p entql.ValueP) {
	f.Where(p.Field(exchangerate.FieldAppID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *ExchangeRateFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(exchangerate.FieldCoinTypeID))
}

// WhereMarketValue applies the entql other predicate on the market_value field.
func (f *ExchangeRateFilter) WhereMarketValue(p entql.OtherP) {
	f.Where(p.Field(exchangerate.FieldMarketValue))
}

// WhereSettleValue applies the entql other predicate on the settle_value field.
func (f *ExchangeRateFilter) WhereSettleValue(p entql.OtherP) {
	f.Where(p.Field(exchangerate.FieldSettleValue))
}

// WhereSettlePercent applies the entql uint32 predicate on the settle_percent field.
func (f *ExchangeRateFilter) WhereSettlePercent(p entql.Uint32P) {
	f.Where(p.Field(exchangerate.FieldSettlePercent))
}

// WhereSettleTips applies the entql json.RawMessage predicate on the settle_tips field.
func (f *ExchangeRateFilter) WhereSettleTips(p entql.BytesP) {
	f.Where(p.Field(exchangerate.FieldSettleTips))
}

// WhereSetter applies the entql [16]byte predicate on the setter field.
func (f *ExchangeRateFilter) WhereSetter(p entql.ValueP) {
	f.Where(p.Field(exchangerate.FieldSetter))
}

// addPredicate implements the predicateAdder interface.
func (fq *FiatQuery) addPredicate(pred func(s *sql.Selector)) {
	fq.predicates = append(fq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the FiatQuery builder.
func (fq *FiatQuery) Filter() *FiatFilter {
	return &FiatFilter{config: fq.config, predicateAdder: fq}
}

// addPredicate implements the predicateAdder interface.
func (m *FiatMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the FiatMutation builder.
func (m *FiatMutation) Filter() *FiatFilter {
	return &FiatFilter{config: m.config, predicateAdder: m}
}

// FiatFilter provides a generic filtering capability at runtime for FiatQuery.
type FiatFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *FiatFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[13].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *FiatFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(fiat.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *FiatFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiat.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *FiatFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiat.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *FiatFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(fiat.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *FiatFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(fiat.FieldEntID))
}

// WhereName applies the entql string predicate on the name field.
func (f *FiatFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(fiat.FieldName))
}

// WhereLogo applies the entql string predicate on the logo field.
func (f *FiatFilter) WhereLogo(p entql.StringP) {
	f.Where(p.Field(fiat.FieldLogo))
}

// WhereUnit applies the entql string predicate on the unit field.
func (f *FiatFilter) WhereUnit(p entql.StringP) {
	f.Where(p.Field(fiat.FieldUnit))
}

// addPredicate implements the predicateAdder interface.
func (fcq *FiatCurrencyQuery) addPredicate(pred func(s *sql.Selector)) {
	fcq.predicates = append(fcq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the FiatCurrencyQuery builder.
func (fcq *FiatCurrencyQuery) Filter() *FiatCurrencyFilter {
	return &FiatCurrencyFilter{config: fcq.config, predicateAdder: fcq}
}

// addPredicate implements the predicateAdder interface.
func (m *FiatCurrencyMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the FiatCurrencyMutation builder.
func (m *FiatCurrencyMutation) Filter() *FiatCurrencyFilter {
	return &FiatCurrencyFilter{config: m.config, predicateAdder: m}
}

// FiatCurrencyFilter provides a generic filtering capability at runtime for FiatCurrencyQuery.
type FiatCurrencyFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *FiatCurrencyFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[14].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *FiatCurrencyFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrency.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *FiatCurrencyFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrency.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *FiatCurrencyFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrency.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *FiatCurrencyFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrency.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *FiatCurrencyFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrency.FieldEntID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *FiatCurrencyFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrency.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *FiatCurrencyFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(fiatcurrency.FieldFeedType))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *FiatCurrencyFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(fiatcurrency.FieldMarketValueLow))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *FiatCurrencyFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(fiatcurrency.FieldMarketValueHigh))
}

// addPredicate implements the predicateAdder interface.
func (fcfq *FiatCurrencyFeedQuery) addPredicate(pred func(s *sql.Selector)) {
	fcfq.predicates = append(fcfq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the FiatCurrencyFeedQuery builder.
func (fcfq *FiatCurrencyFeedQuery) Filter() *FiatCurrencyFeedFilter {
	return &FiatCurrencyFeedFilter{config: fcfq.config, predicateAdder: fcfq}
}

// addPredicate implements the predicateAdder interface.
func (m *FiatCurrencyFeedMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the FiatCurrencyFeedMutation builder.
func (m *FiatCurrencyFeedMutation) Filter() *FiatCurrencyFeedFilter {
	return &FiatCurrencyFeedFilter{config: m.config, predicateAdder: m}
}

// FiatCurrencyFeedFilter provides a generic filtering capability at runtime for FiatCurrencyFeedQuery.
type FiatCurrencyFeedFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *FiatCurrencyFeedFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[15].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *FiatCurrencyFeedFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyfeed.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *FiatCurrencyFeedFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyfeed.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *FiatCurrencyFeedFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyfeed.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *FiatCurrencyFeedFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyfeed.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *FiatCurrencyFeedFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrencyfeed.FieldEntID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *FiatCurrencyFeedFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrencyfeed.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *FiatCurrencyFeedFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(fiatcurrencyfeed.FieldFeedType))
}

// WhereFeedFiatName applies the entql string predicate on the feed_fiat_name field.
func (f *FiatCurrencyFeedFilter) WhereFeedFiatName(p entql.StringP) {
	f.Where(p.Field(fiatcurrencyfeed.FieldFeedFiatName))
}

// WhereDisabled applies the entql bool predicate on the disabled field.
func (f *FiatCurrencyFeedFilter) WhereDisabled(p entql.BoolP) {
	f.Where(p.Field(fiatcurrencyfeed.FieldDisabled))
}

// addPredicate implements the predicateAdder interface.
func (fchq *FiatCurrencyHistoryQuery) addPredicate(pred func(s *sql.Selector)) {
	fchq.predicates = append(fchq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the FiatCurrencyHistoryQuery builder.
func (fchq *FiatCurrencyHistoryQuery) Filter() *FiatCurrencyHistoryFilter {
	return &FiatCurrencyHistoryFilter{config: fchq.config, predicateAdder: fchq}
}

// addPredicate implements the predicateAdder interface.
func (m *FiatCurrencyHistoryMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the FiatCurrencyHistoryMutation builder.
func (m *FiatCurrencyHistoryMutation) Filter() *FiatCurrencyHistoryFilter {
	return &FiatCurrencyHistoryFilter{config: m.config, predicateAdder: m}
}

// FiatCurrencyHistoryFilter provides a generic filtering capability at runtime for FiatCurrencyHistoryQuery.
type FiatCurrencyHistoryFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *FiatCurrencyHistoryFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[16].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *FiatCurrencyHistoryFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyhistory.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *FiatCurrencyHistoryFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyhistory.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *FiatCurrencyHistoryFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyhistory.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *FiatCurrencyHistoryFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(fiatcurrencyhistory.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *FiatCurrencyHistoryFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrencyhistory.FieldEntID))
}

// WhereFiatID applies the entql [16]byte predicate on the fiat_id field.
func (f *FiatCurrencyHistoryFilter) WhereFiatID(p entql.ValueP) {
	f.Where(p.Field(fiatcurrencyhistory.FieldFiatID))
}

// WhereFeedType applies the entql string predicate on the feed_type field.
func (f *FiatCurrencyHistoryFilter) WhereFeedType(p entql.StringP) {
	f.Where(p.Field(fiatcurrencyhistory.FieldFeedType))
}

// WhereMarketValueLow applies the entql other predicate on the market_value_low field.
func (f *FiatCurrencyHistoryFilter) WhereMarketValueLow(p entql.OtherP) {
	f.Where(p.Field(fiatcurrencyhistory.FieldMarketValueLow))
}

// WhereMarketValueHigh applies the entql other predicate on the market_value_high field.
func (f *FiatCurrencyHistoryFilter) WhereMarketValueHigh(p entql.OtherP) {
	f.Where(p.Field(fiatcurrencyhistory.FieldMarketValueHigh))
}

// addPredicate implements the predicateAdder interface.
func (sq *SettingQuery) addPredicate(pred func(s *sql.Selector)) {
	sq.predicates = append(sq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the SettingQuery builder.
func (sq *SettingQuery) Filter() *SettingFilter {
	return &SettingFilter{config: sq.config, predicateAdder: sq}
}

// addPredicate implements the predicateAdder interface.
func (m *SettingMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the SettingMutation builder.
func (m *SettingMutation) Filter() *SettingFilter {
	return &SettingFilter{config: m.config, predicateAdder: m}
}

// SettingFilter provides a generic filtering capability at runtime for SettingQuery.
type SettingFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *SettingFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[17].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *SettingFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(setting.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *SettingFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(setting.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *SettingFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(setting.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *SettingFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(setting.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *SettingFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(setting.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *SettingFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(setting.FieldCoinTypeID))
}

// WhereFeeCoinTypeID applies the entql [16]byte predicate on the fee_coin_type_id field.
func (f *SettingFilter) WhereFeeCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(setting.FieldFeeCoinTypeID))
}

// WhereWithdrawFeeByStableUsd applies the entql bool predicate on the withdraw_fee_by_stable_usd field.
func (f *SettingFilter) WhereWithdrawFeeByStableUsd(p entql.BoolP) {
	f.Where(p.Field(setting.FieldWithdrawFeeByStableUsd))
}

// WhereWithdrawFeeAmount applies the entql other predicate on the withdraw_fee_amount field.
func (f *SettingFilter) WhereWithdrawFeeAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldWithdrawFeeAmount))
}

// WhereCollectFeeAmount applies the entql other predicate on the collect_fee_amount field.
func (f *SettingFilter) WhereCollectFeeAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldCollectFeeAmount))
}

// WhereHotWalletFeeAmount applies the entql other predicate on the hot_wallet_fee_amount field.
func (f *SettingFilter) WhereHotWalletFeeAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldHotWalletFeeAmount))
}

// WhereLowFeeAmount applies the entql other predicate on the low_fee_amount field.
func (f *SettingFilter) WhereLowFeeAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldLowFeeAmount))
}

// WhereHotLowFeeAmount applies the entql other predicate on the hot_low_fee_amount field.
func (f *SettingFilter) WhereHotLowFeeAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldHotLowFeeAmount))
}

// WhereHotWalletAccountAmount applies the entql other predicate on the hot_wallet_account_amount field.
func (f *SettingFilter) WhereHotWalletAccountAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldHotWalletAccountAmount))
}

// WherePaymentAccountCollectAmount applies the entql other predicate on the payment_account_collect_amount field.
func (f *SettingFilter) WherePaymentAccountCollectAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldPaymentAccountCollectAmount))
}

// WhereLeastTransferAmount applies the entql other predicate on the least_transfer_amount field.
func (f *SettingFilter) WhereLeastTransferAmount(p entql.OtherP) {
	f.Where(p.Field(setting.FieldLeastTransferAmount))
}

// WhereNeedMemo applies the entql bool predicate on the need_memo field.
func (f *SettingFilter) WhereNeedMemo(p entql.BoolP) {
	f.Where(p.Field(setting.FieldNeedMemo))
}

// WhereRefreshCurrency applies the entql bool predicate on the refresh_currency field.
func (f *SettingFilter) WhereRefreshCurrency(p entql.BoolP) {
	f.Where(p.Field(setting.FieldRefreshCurrency))
}

// WhereCheckNewAddressBalance applies the entql bool predicate on the check_new_address_balance field.
func (f *SettingFilter) WhereCheckNewAddressBalance(p entql.BoolP) {
	f.Where(p.Field(setting.FieldCheckNewAddressBalance))
}

// addPredicate implements the predicateAdder interface.
func (tq *TranQuery) addPredicate(pred func(s *sql.Selector)) {
	tq.predicates = append(tq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the TranQuery builder.
func (tq *TranQuery) Filter() *TranFilter {
	return &TranFilter{config: tq.config, predicateAdder: tq}
}

// addPredicate implements the predicateAdder interface.
func (m *TranMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the TranMutation builder.
func (m *TranMutation) Filter() *TranFilter {
	return &TranFilter{config: m.config, predicateAdder: m}
}

// TranFilter provides a generic filtering capability at runtime for TranQuery.
type TranFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *TranFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[18].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql uint32 predicate on the id field.
func (f *TranFilter) WhereID(p entql.Uint32P) {
	f.Where(p.Field(tran.FieldID))
}

// WhereCreatedAt applies the entql uint32 predicate on the created_at field.
func (f *TranFilter) WhereCreatedAt(p entql.Uint32P) {
	f.Where(p.Field(tran.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql uint32 predicate on the updated_at field.
func (f *TranFilter) WhereUpdatedAt(p entql.Uint32P) {
	f.Where(p.Field(tran.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql uint32 predicate on the deleted_at field.
func (f *TranFilter) WhereDeletedAt(p entql.Uint32P) {
	f.Where(p.Field(tran.FieldDeletedAt))
}

// WhereEntID applies the entql [16]byte predicate on the ent_id field.
func (f *TranFilter) WhereEntID(p entql.ValueP) {
	f.Where(p.Field(tran.FieldEntID))
}

// WhereCoinTypeID applies the entql [16]byte predicate on the coin_type_id field.
func (f *TranFilter) WhereCoinTypeID(p entql.ValueP) {
	f.Where(p.Field(tran.FieldCoinTypeID))
}

// WhereFromAccountID applies the entql [16]byte predicate on the from_account_id field.
func (f *TranFilter) WhereFromAccountID(p entql.ValueP) {
	f.Where(p.Field(tran.FieldFromAccountID))
}

// WhereToAccountID applies the entql [16]byte predicate on the to_account_id field.
func (f *TranFilter) WhereToAccountID(p entql.ValueP) {
	f.Where(p.Field(tran.FieldToAccountID))
}

// WhereAmount applies the entql other predicate on the amount field.
func (f *TranFilter) WhereAmount(p entql.OtherP) {
	f.Where(p.Field(tran.FieldAmount))
}

// WhereFeeAmount applies the entql other predicate on the fee_amount field.
func (f *TranFilter) WhereFeeAmount(p entql.OtherP) {
	f.Where(p.Field(tran.FieldFeeAmount))
}

// WhereChainTxID applies the entql string predicate on the chain_tx_id field.
func (f *TranFilter) WhereChainTxID(p entql.StringP) {
	f.Where(p.Field(tran.FieldChainTxID))
}

// WhereState applies the entql string predicate on the state field.
func (f *TranFilter) WhereState(p entql.StringP) {
	f.Where(p.Field(tran.FieldState))
}

// WhereExtra applies the entql string predicate on the extra field.
func (f *TranFilter) WhereExtra(p entql.StringP) {
	f.Where(p.Field(tran.FieldExtra))
}

// WhereType applies the entql string predicate on the type field.
func (f *TranFilter) WhereType(p entql.StringP) {
	f.Where(p.Field(tran.FieldType))
}