// Code generated by go-queryset. DO NOT EDIT.
package model

import (
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/jinzhu/gorm"
)

// ===== BEGIN of all query sets

// ===== BEGIN of query set GameCardGoodsQuerySet

// GameCardGoodsQuerySet is an queryset type for GameCardGoods
type GameCardGoodsQuerySet struct {
	db *gorm.DB
}

// NewGameCardGoodsQuerySet constructs new GameCardGoodsQuerySet
func NewGameCardGoodsQuerySet(db *gorm.DB) GameCardGoodsQuerySet {
	return GameCardGoodsQuerySet{
		db: db.Model(&GameCardGoods{}),
	}
}

func (qs GameCardGoodsQuerySet) w(db *gorm.DB) GameCardGoodsQuerySet {
	return NewGameCardGoodsQuerySet(db)
}

func (qs GameCardGoodsQuerySet) Select(fields ...GameCardGoodsDBSchemaField) GameCardGoodsQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameCardGoods) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameCardGoods) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) All(ret *[]GameCardGoods) error {
	return qs.db.Find(ret).Error
}

// CardTypeEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeEq(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type = ?", cardType))
}

// CardTypeGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeGt(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type > ?", cardType))
}

// CardTypeGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeGte(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type >= ?", cardType))
}

// CardTypeIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeIn(cardType ...string) GameCardGoodsQuerySet {
	if len(cardType) == 0 {
		qs.db.AddError(errors.New("must at least pass one cardType in CardTypeIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("card_type IN (?)", cardType))
}

// CardTypeLike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeLike(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type LIKE ?", cardType))
}

// CardTypeLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeLt(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type < ?", cardType))
}

// CardTypeLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeLte(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type <= ?", cardType))
}

// CardTypeNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeNe(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type != ?", cardType))
}

// CardTypeNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeNotIn(cardType ...string) GameCardGoodsQuerySet {
	if len(cardType) == 0 {
		qs.db.AddError(errors.New("must at least pass one cardType in CardTypeNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("card_type NOT IN (?)", cardType))
}

// CardTypeNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CardTypeNotlike(cardType string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("card_type NOT LIKE ?", cardType))
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtEq(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtGt(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtGte(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtLt(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtLte(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) CreatedAtNe(createdAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) Delete() error {
	return qs.db.Delete(GameCardGoods{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameCardGoods{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameCardGoods{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtEq(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtGt(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtGte(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtIsNotNull() GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtIsNull() GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtLt(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtLte(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) DeletedAtNe(deletedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// FunctionStateEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateEq(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state = ?", functionState))
}

// FunctionStateGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateGt(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state > ?", functionState))
}

// FunctionStateGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateGte(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state >= ?", functionState))
}

// FunctionStateIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateIn(functionState ...uint32) GameCardGoodsQuerySet {
	if len(functionState) == 0 {
		qs.db.AddError(errors.New("must at least pass one functionState in FunctionStateIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("function_state IN (?)", functionState))
}

// FunctionStateLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateLt(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state < ?", functionState))
}

// FunctionStateLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateLte(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state <= ?", functionState))
}

// FunctionStateNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateNe(functionState uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("function_state != ?", functionState))
}

// FunctionStateNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) FunctionStateNotIn(functionState ...uint32) GameCardGoodsQuerySet {
	if len(functionState) == 0 {
		qs.db.AddError(errors.New("must at least pass one functionState in FunctionStateNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("function_state NOT IN (?)", functionState))
}

// GameCardIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdEq(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id = ?", gameCardId))
}

// GameCardIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdGt(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id > ?", gameCardId))
}

// GameCardIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdGte(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id >= ?", gameCardId))
}

// GameCardIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdIn(gameCardId ...uint64) GameCardGoodsQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id IN (?)", gameCardId))
}

// GameCardIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdLt(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id < ?", gameCardId))
}

// GameCardIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdLte(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id <= ?", gameCardId))
}

// GameCardIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdNe(gameCardId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("game_card_id != ?", gameCardId))
}

// GameCardIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GameCardIdNotIn(gameCardId ...uint64) GameCardGoodsQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id NOT IN (?)", gameCardId))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) GetUpdater() GameCardGoodsUpdater {
	return NewGameCardGoodsUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDEq(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDGt(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDGte(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDIn(ID ...uint32) GameCardGoodsQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDLt(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDLte(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDNe(ID uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) IDNotIn(ID ...uint32) GameCardGoodsQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) Limit(limit int) GameCardGoodsQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) Offset(offset int) GameCardGoodsQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameCardGoodsQuerySet) One(ret *GameCardGoods) error {
	return qs.db.First(ret).Error
}

// OrderAscByCardType is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByCardType() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("card_type ASC"))
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByCreatedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByDeletedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByFunctionState is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByFunctionState() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("function_state ASC"))
}

// OrderAscByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByGameCardId() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("game_card_id ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByID() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByProvider is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByProvider() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("provider ASC"))
}

// OrderAscBySerialNumber is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscBySerialNumber() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("serial_number ASC"))
}

// OrderAscByShareProfitType is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByShareProfitType() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("share_profit_type ASC"))
}

// OrderAscByStatus is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByStatus() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("status ASC"))
}

// OrderAscByStoreId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByStoreId() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("store_id ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByUpdatedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderDescByCardType is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByCardType() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("card_type DESC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByCreatedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByDeletedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByFunctionState is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByFunctionState() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("function_state DESC"))
}

// OrderDescByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByGameCardId() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("game_card_id DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByID() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByProvider is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByProvider() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("provider DESC"))
}

// OrderDescBySerialNumber is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescBySerialNumber() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("serial_number DESC"))
}

// OrderDescByShareProfitType is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByShareProfitType() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("share_profit_type DESC"))
}

// OrderDescByStatus is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByStatus() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("status DESC"))
}

// OrderDescByStoreId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByStoreId() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("store_id DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByUpdatedAt() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// ProviderEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderEq(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider = ?", provider))
}

// ProviderGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderGt(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider > ?", provider))
}

// ProviderGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderGte(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider >= ?", provider))
}

// ProviderIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderIn(provider ...string) GameCardGoodsQuerySet {
	if len(provider) == 0 {
		qs.db.AddError(errors.New("must at least pass one provider in ProviderIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("provider IN (?)", provider))
}

// ProviderLike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderLike(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider LIKE ?", provider))
}

// ProviderLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderLt(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider < ?", provider))
}

// ProviderLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderLte(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider <= ?", provider))
}

// ProviderNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderNe(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider != ?", provider))
}

// ProviderNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderNotIn(provider ...string) GameCardGoodsQuerySet {
	if len(provider) == 0 {
		qs.db.AddError(errors.New("must at least pass one provider in ProviderNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("provider NOT IN (?)", provider))
}

// ProviderNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ProviderNotlike(provider string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("provider NOT LIKE ?", provider))
}

// SerialNumberEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberEq(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number = ?", serialNumber))
}

// SerialNumberGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberGt(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number > ?", serialNumber))
}

// SerialNumberGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberGte(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number >= ?", serialNumber))
}

// SerialNumberIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberIn(serialNumber ...string) GameCardGoodsQuerySet {
	if len(serialNumber) == 0 {
		qs.db.AddError(errors.New("must at least pass one serialNumber in SerialNumberIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("serial_number IN (?)", serialNumber))
}

// SerialNumberLike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberLike(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number LIKE ?", serialNumber))
}

// SerialNumberLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberLt(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number < ?", serialNumber))
}

// SerialNumberLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberLte(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number <= ?", serialNumber))
}

// SerialNumberNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberNe(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number != ?", serialNumber))
}

// SerialNumberNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberNotIn(serialNumber ...string) GameCardGoodsQuerySet {
	if len(serialNumber) == 0 {
		qs.db.AddError(errors.New("must at least pass one serialNumber in SerialNumberNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("serial_number NOT IN (?)", serialNumber))
}

// SerialNumberNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberNotlike(serialNumber string) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("serial_number NOT LIKE ?", serialNumber))
}

// ShareProfitTypeEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeEq(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type = ?", shareProfitType))
}

// ShareProfitTypeGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeGt(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type > ?", shareProfitType))
}

// ShareProfitTypeGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeGte(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type >= ?", shareProfitType))
}

// ShareProfitTypeIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeIn(shareProfitType ...uint32) GameCardGoodsQuerySet {
	if len(shareProfitType) == 0 {
		qs.db.AddError(errors.New("must at least pass one shareProfitType in ShareProfitTypeIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("share_profit_type IN (?)", shareProfitType))
}

// ShareProfitTypeLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeLt(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type < ?", shareProfitType))
}

// ShareProfitTypeLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeLte(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type <= ?", shareProfitType))
}

// ShareProfitTypeNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeNe(shareProfitType uint32) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("share_profit_type != ?", shareProfitType))
}

// ShareProfitTypeNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) ShareProfitTypeNotIn(shareProfitType ...uint32) GameCardGoodsQuerySet {
	if len(shareProfitType) == 0 {
		qs.db.AddError(errors.New("must at least pass one shareProfitType in ShareProfitTypeNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("share_profit_type NOT IN (?)", shareProfitType))
}

// StatusEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusEq(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status = ?", status))
}

// StatusGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusGt(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status > ?", status))
}

// StatusGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusGte(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status >= ?", status))
}

// StatusIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusIn(status ...uint8) GameCardGoodsQuerySet {
	if len(status) == 0 {
		qs.db.AddError(errors.New("must at least pass one status in StatusIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("status IN (?)", status))
}

// StatusLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusLt(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status < ?", status))
}

// StatusLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusLte(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status <= ?", status))
}

// StatusNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusNe(status uint8) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("status != ?", status))
}

// StatusNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StatusNotIn(status ...uint8) GameCardGoodsQuerySet {
	if len(status) == 0 {
		qs.db.AddError(errors.New("must at least pass one status in StatusNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("status NOT IN (?)", status))
}

// StoreIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdEq(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id = ?", storeId))
}

// StoreIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdGt(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id > ?", storeId))
}

// StoreIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdGte(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id >= ?", storeId))
}

// StoreIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdIn(storeId ...uint64) GameCardGoodsQuerySet {
	if len(storeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeId in StoreIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_id IN (?)", storeId))
}

// StoreIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdLt(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id < ?", storeId))
}

// StoreIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdLte(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id <= ?", storeId))
}

// StoreIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdNe(storeId uint64) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("store_id != ?", storeId))
}

// StoreIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) StoreIdNotIn(storeId ...uint64) GameCardGoodsQuerySet {
	if len(storeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeId in StoreIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_id NOT IN (?)", storeId))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtEq(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtGt(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtGte(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtLt(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtLte(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) UpdatedAtNe(updatedAt time.Time) GameCardGoodsQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// SetCardType is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetCardType(cardType string) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.CardType)] = cardType
	return u
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetCreatedAt(createdAt time.Time) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetDeletedAt(deletedAt *time.Time) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetFunctionState is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetFunctionState(functionState uint32) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.FunctionState)] = functionState
	return u
}

// SetGameCardId is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetGameCardId(gameCardId uint64) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.GameCardId)] = gameCardId
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetID(ID uint32) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.ID)] = ID
	return u
}

// SetProvider is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetProvider(provider string) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.Provider)] = provider
	return u
}

// SetSerialNumber is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetSerialNumber(serialNumber string) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.SerialNumber)] = serialNumber
	return u
}

// SetShareProfitType is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetShareProfitType(shareProfitType uint32) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.ShareProfitType)] = shareProfitType
	return u
}

// SetStatus is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetStatus(status uint8) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.Status)] = status
	return u
}

// SetStoreId is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetStoreId(storeId uint64) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.StoreId)] = storeId
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetUpdatedAt(updatedAt time.Time) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.UpdatedAt)] = updatedAt
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameCardGoodsQuerySet

// ===== BEGIN of GameCardGoods modifiers

// GameCardGoodsDBSchemaField describes database schema field. It requires for method 'Update'
type GameCardGoodsDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameCardGoodsDBSchemaField) String() string {
	return string(f)
}

// GameCardGoodsDBSchema stores db field names of GameCardGoods
var GameCardGoodsDBSchema = struct {
	ID              GameCardGoodsDBSchemaField
	CreatedAt       GameCardGoodsDBSchemaField
	UpdatedAt       GameCardGoodsDBSchemaField
	DeletedAt       GameCardGoodsDBSchemaField
	GameCardId      GameCardGoodsDBSchemaField
	SerialNumber    GameCardGoodsDBSchemaField
	Status          GameCardGoodsDBSchemaField
	StoreId         GameCardGoodsDBSchemaField
	Provider        GameCardGoodsDBSchemaField
	CardType        GameCardGoodsDBSchemaField
	FunctionState   GameCardGoodsDBSchemaField
	ShareProfitType GameCardGoodsDBSchemaField
}{

	ID:              GameCardGoodsDBSchemaField("id"),
	CreatedAt:       GameCardGoodsDBSchemaField("created_at"),
	UpdatedAt:       GameCardGoodsDBSchemaField("updated_at"),
	DeletedAt:       GameCardGoodsDBSchemaField("deleted_at"),
	GameCardId:      GameCardGoodsDBSchemaField("game_card_id"),
	SerialNumber:    GameCardGoodsDBSchemaField("serial_number"),
	Status:          GameCardGoodsDBSchemaField("status"),
	StoreId:         GameCardGoodsDBSchemaField("store_id"),
	Provider:        GameCardGoodsDBSchemaField("provider"),
	CardType:        GameCardGoodsDBSchemaField("card_type"),
	FunctionState:   GameCardGoodsDBSchemaField("function_state"),
	ShareProfitType: GameCardGoodsDBSchemaField("share_profit_type"),
}

// Update updates GameCardGoods fields by primary key
// nolint: dupl
func (o *GameCardGoods) Update(db *gorm.DB, fields ...GameCardGoodsDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":                o.ID,
		"created_at":        o.CreatedAt,
		"updated_at":        o.UpdatedAt,
		"deleted_at":        o.DeletedAt,
		"game_card_id":      o.GameCardId,
		"serial_number":     o.SerialNumber,
		"status":            o.Status,
		"store_id":          o.StoreId,
		"provider":          o.Provider,
		"card_type":         o.CardType,
		"function_state":    o.FunctionState,
		"share_profit_type": o.ShareProfitType,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameCardGoods %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameCardGoodsUpdater is an GameCardGoods updates manager
type GameCardGoodsUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameCardGoodsUpdater creates new GameCardGoods updater
// nolint: dupl
func NewGameCardGoodsUpdater(db *gorm.DB) GameCardGoodsUpdater {
	return GameCardGoodsUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameCardGoods{}),
	}
}

// ===== END of GameCardGoods modifiers

// ===== BEGIN of query set GameCardGoodsStockQuerySet

// GameCardGoodsStockQuerySet is an queryset type for GameCardGoodsStock
type GameCardGoodsStockQuerySet struct {
	db *gorm.DB
}

// NewGameCardGoodsStockQuerySet constructs new GameCardGoodsStockQuerySet
func NewGameCardGoodsStockQuerySet(db *gorm.DB) GameCardGoodsStockQuerySet {
	return GameCardGoodsStockQuerySet{
		db: db.Model(&GameCardGoodsStock{}),
	}
}

func (qs GameCardGoodsStockQuerySet) w(db *gorm.DB) GameCardGoodsStockQuerySet {
	return NewGameCardGoodsStockQuerySet(db)
}

func (qs GameCardGoodsStockQuerySet) Select(fields ...GameCardGoodsStockDBSchemaField) GameCardGoodsStockQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameCardGoodsStock) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameCardGoodsStock) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) All(ret *[]GameCardGoodsStock) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtEq(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtGt(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtGte(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtLt(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtLte(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) CreatedAtNe(createdAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) Delete() error {
	return qs.db.Delete(GameCardGoodsStock{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameCardGoodsStock{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameCardGoodsStock{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtEq(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtGt(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtGte(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtIsNotNull() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtIsNull() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtLt(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtLte(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) DeletedAtNe(deletedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// GameCardIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdEq(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id = ?", gameCardId))
}

// GameCardIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdGt(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id > ?", gameCardId))
}

// GameCardIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdGte(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id >= ?", gameCardId))
}

// GameCardIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdIn(gameCardId ...uint64) GameCardGoodsStockQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id IN (?)", gameCardId))
}

// GameCardIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdLt(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id < ?", gameCardId))
}

// GameCardIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdLte(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id <= ?", gameCardId))
}

// GameCardIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdNe(gameCardId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("game_card_id != ?", gameCardId))
}

// GameCardIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GameCardIdNotIn(gameCardId ...uint64) GameCardGoodsStockQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id NOT IN (?)", gameCardId))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) GetUpdater() GameCardGoodsStockUpdater {
	return NewGameCardGoodsStockUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDEq(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDGt(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDGte(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDIn(ID ...uint32) GameCardGoodsStockQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDLt(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDLte(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDNe(ID uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) IDNotIn(ID ...uint32) GameCardGoodsStockQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) Limit(limit int) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) Offset(offset int) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameCardGoodsStockQuerySet) One(ret *GameCardGoodsStock) error {
	return qs.db.First(ret).Error
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByCreatedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByDeletedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByGameCardId() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("game_card_id ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByID() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByOrderCount is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByOrderCount() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("order_count ASC"))
}

// OrderAscByRentStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByRentStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("rent_stock ASC"))
}

// OrderAscByStoreId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByStoreId() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("store_id ASC"))
}

// OrderAscByStoreStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByStoreStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("store_stock ASC"))
}

// OrderAscByTotalStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByTotalStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("total_stock ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByUpdatedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderAscByUserHoldStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderAscByUserHoldStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("user_hold_stock ASC"))
}

// OrderCountEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountEq(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count = ?", orderCount))
}

// OrderCountGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountGt(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count > ?", orderCount))
}

// OrderCountGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountGte(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count >= ?", orderCount))
}

// OrderCountIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountIn(orderCount ...uint32) GameCardGoodsStockQuerySet {
	if len(orderCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one orderCount in OrderCountIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("order_count IN (?)", orderCount))
}

// OrderCountLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountLt(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count < ?", orderCount))
}

// OrderCountLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountLte(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count <= ?", orderCount))
}

// OrderCountNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountNe(orderCount uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("order_count != ?", orderCount))
}

// OrderCountNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderCountNotIn(orderCount ...uint32) GameCardGoodsStockQuerySet {
	if len(orderCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one orderCount in OrderCountNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("order_count NOT IN (?)", orderCount))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByCreatedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByDeletedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByGameCardId() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("game_card_id DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByID() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByOrderCount is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByOrderCount() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("order_count DESC"))
}

// OrderDescByRentStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByRentStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("rent_stock DESC"))
}

// OrderDescByStoreId is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByStoreId() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("store_id DESC"))
}

// OrderDescByStoreStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByStoreStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("store_stock DESC"))
}

// OrderDescByTotalStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByTotalStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("total_stock DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByUpdatedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// OrderDescByUserHoldStock is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByUserHoldStock() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("user_hold_stock DESC"))
}

// RentStockEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockEq(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock = ?", rentStock))
}

// RentStockGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockGt(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock > ?", rentStock))
}

// RentStockGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockGte(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock >= ?", rentStock))
}

// RentStockIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockIn(rentStock ...uint32) GameCardGoodsStockQuerySet {
	if len(rentStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one rentStock in RentStockIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("rent_stock IN (?)", rentStock))
}

// RentStockLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockLt(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock < ?", rentStock))
}

// RentStockLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockLte(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock <= ?", rentStock))
}

// RentStockNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockNe(rentStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("rent_stock != ?", rentStock))
}

// RentStockNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) RentStockNotIn(rentStock ...uint32) GameCardGoodsStockQuerySet {
	if len(rentStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one rentStock in RentStockNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("rent_stock NOT IN (?)", rentStock))
}

// StoreIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdEq(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id = ?", storeId))
}

// StoreIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdGt(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id > ?", storeId))
}

// StoreIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdGte(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id >= ?", storeId))
}

// StoreIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdIn(storeId ...uint64) GameCardGoodsStockQuerySet {
	if len(storeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeId in StoreIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_id IN (?)", storeId))
}

// StoreIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdLt(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id < ?", storeId))
}

// StoreIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdLte(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id <= ?", storeId))
}

// StoreIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdNe(storeId uint64) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_id != ?", storeId))
}

// StoreIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreIdNotIn(storeId ...uint64) GameCardGoodsStockQuerySet {
	if len(storeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeId in StoreIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_id NOT IN (?)", storeId))
}

// StoreStockEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockEq(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock = ?", storeStock))
}

// StoreStockGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockGt(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock > ?", storeStock))
}

// StoreStockGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockGte(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock >= ?", storeStock))
}

// StoreStockIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockIn(storeStock ...uint32) GameCardGoodsStockQuerySet {
	if len(storeStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeStock in StoreStockIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_stock IN (?)", storeStock))
}

// StoreStockLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockLt(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock < ?", storeStock))
}

// StoreStockLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockLte(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock <= ?", storeStock))
}

// StoreStockNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockNe(storeStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("store_stock != ?", storeStock))
}

// StoreStockNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) StoreStockNotIn(storeStock ...uint32) GameCardGoodsStockQuerySet {
	if len(storeStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one storeStock in StoreStockNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("store_stock NOT IN (?)", storeStock))
}

// TotalStockEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockEq(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock = ?", totalStock))
}

// TotalStockGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockGt(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock > ?", totalStock))
}

// TotalStockGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockGte(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock >= ?", totalStock))
}

// TotalStockIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockIn(totalStock ...uint32) GameCardGoodsStockQuerySet {
	if len(totalStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one totalStock in TotalStockIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("total_stock IN (?)", totalStock))
}

// TotalStockLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockLt(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock < ?", totalStock))
}

// TotalStockLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockLte(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock <= ?", totalStock))
}

// TotalStockNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockNe(totalStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("total_stock != ?", totalStock))
}

// TotalStockNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) TotalStockNotIn(totalStock ...uint32) GameCardGoodsStockQuerySet {
	if len(totalStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one totalStock in TotalStockNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("total_stock NOT IN (?)", totalStock))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtEq(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtGt(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtGte(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtLt(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtLte(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UpdatedAtNe(updatedAt time.Time) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// UserHoldStockEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockEq(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock = ?", userHoldStock))
}

// UserHoldStockGt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockGt(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock > ?", userHoldStock))
}

// UserHoldStockGte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockGte(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock >= ?", userHoldStock))
}

// UserHoldStockIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockIn(userHoldStock ...uint32) GameCardGoodsStockQuerySet {
	if len(userHoldStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one userHoldStock in UserHoldStockIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("user_hold_stock IN (?)", userHoldStock))
}

// UserHoldStockLt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockLt(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock < ?", userHoldStock))
}

// UserHoldStockLte is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockLte(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock <= ?", userHoldStock))
}

// UserHoldStockNe is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockNe(userHoldStock uint32) GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Where("user_hold_stock != ?", userHoldStock))
}

// UserHoldStockNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) UserHoldStockNotIn(userHoldStock ...uint32) GameCardGoodsStockQuerySet {
	if len(userHoldStock) == 0 {
		qs.db.AddError(errors.New("must at least pass one userHoldStock in UserHoldStockNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("user_hold_stock NOT IN (?)", userHoldStock))
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetCreatedAt(createdAt time.Time) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetDeletedAt(deletedAt *time.Time) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetGameCardId is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetGameCardId(gameCardId uint64) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.GameCardId)] = gameCardId
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetID(ID uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.ID)] = ID
	return u
}

// SetOrderCount is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetOrderCount(orderCount uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.OrderCount)] = orderCount
	return u
}

// SetRentStock is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetRentStock(rentStock uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.RentStock)] = rentStock
	return u
}

// SetStoreId is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetStoreId(storeId uint64) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.StoreId)] = storeId
	return u
}

// SetStoreStock is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetStoreStock(storeStock uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.StoreStock)] = storeStock
	return u
}

// SetTotalStock is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetTotalStock(totalStock uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.TotalStock)] = totalStock
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetUpdatedAt(updatedAt time.Time) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.UpdatedAt)] = updatedAt
	return u
}

// SetUserHoldStock is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetUserHoldStock(userHoldStock uint32) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.UserHoldStock)] = userHoldStock
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameCardGoodsStockQuerySet

// ===== BEGIN of GameCardGoodsStock modifiers

// GameCardGoodsStockDBSchemaField describes database schema field. It requires for method 'Update'
type GameCardGoodsStockDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameCardGoodsStockDBSchemaField) String() string {
	return string(f)
}

// GameCardGoodsStockDBSchema stores db field names of GameCardGoodsStock
var GameCardGoodsStockDBSchema = struct {
	ID            GameCardGoodsStockDBSchemaField
	CreatedAt     GameCardGoodsStockDBSchemaField
	UpdatedAt     GameCardGoodsStockDBSchemaField
	DeletedAt     GameCardGoodsStockDBSchemaField
	StoreId       GameCardGoodsStockDBSchemaField
	GameCardId    GameCardGoodsStockDBSchemaField
	StoreStock    GameCardGoodsStockDBSchemaField
	RentStock     GameCardGoodsStockDBSchemaField
	UserHoldStock GameCardGoodsStockDBSchemaField
	OrderCount    GameCardGoodsStockDBSchemaField
	TotalStock    GameCardGoodsStockDBSchemaField
}{

	ID:            GameCardGoodsStockDBSchemaField("id"),
	CreatedAt:     GameCardGoodsStockDBSchemaField("created_at"),
	UpdatedAt:     GameCardGoodsStockDBSchemaField("updated_at"),
	DeletedAt:     GameCardGoodsStockDBSchemaField("deleted_at"),
	StoreId:       GameCardGoodsStockDBSchemaField("store_id"),
	GameCardId:    GameCardGoodsStockDBSchemaField("game_card_id"),
	StoreStock:    GameCardGoodsStockDBSchemaField("store_stock"),
	RentStock:     GameCardGoodsStockDBSchemaField("rent_stock"),
	UserHoldStock: GameCardGoodsStockDBSchemaField("user_hold_stock"),
	OrderCount:    GameCardGoodsStockDBSchemaField("order_count"),
	TotalStock:    GameCardGoodsStockDBSchemaField("total_stock"),
}

// Update updates GameCardGoodsStock fields by primary key
// nolint: dupl
func (o *GameCardGoodsStock) Update(db *gorm.DB, fields ...GameCardGoodsStockDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":              o.ID,
		"created_at":      o.CreatedAt,
		"updated_at":      o.UpdatedAt,
		"deleted_at":      o.DeletedAt,
		"store_id":        o.StoreId,
		"game_card_id":    o.GameCardId,
		"store_stock":     o.StoreStock,
		"rent_stock":      o.RentStock,
		"user_hold_stock": o.UserHoldStock,
		"order_count":     o.OrderCount,
		"total_stock":     o.TotalStock,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameCardGoodsStock %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameCardGoodsStockUpdater is an GameCardGoodsStock updates manager
type GameCardGoodsStockUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameCardGoodsStockUpdater creates new GameCardGoodsStock updater
// nolint: dupl
func NewGameCardGoodsStockUpdater(db *gorm.DB) GameCardGoodsStockUpdater {
	return GameCardGoodsStockUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameCardGoodsStock{}),
	}
}

// ===== END of GameCardGoodsStock modifiers

// ===== BEGIN of query set GameCardLabelQuerySet

// GameCardLabelQuerySet is an queryset type for GameCardLabel
type GameCardLabelQuerySet struct {
	db *gorm.DB
}

// NewGameCardLabelQuerySet constructs new GameCardLabelQuerySet
func NewGameCardLabelQuerySet(db *gorm.DB) GameCardLabelQuerySet {
	return GameCardLabelQuerySet{
		db: db.Model(&GameCardLabel{}),
	}
}

func (qs GameCardLabelQuerySet) w(db *gorm.DB) GameCardLabelQuerySet {
	return NewGameCardLabelQuerySet(db)
}

func (qs GameCardLabelQuerySet) Select(fields ...GameCardLabelDBSchemaField) GameCardLabelQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameCardLabel) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameCardLabel) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) All(ret *[]GameCardLabel) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtEq(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtGt(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtGte(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtLt(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtLte(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) CreatedAtNe(createdAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) Delete() error {
	return qs.db.Delete(GameCardLabel{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameCardLabel{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameCardLabel{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtEq(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtGt(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtGte(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtIsNotNull() GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtIsNull() GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtLt(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtLte(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) DeletedAtNe(deletedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// GameCardIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdEq(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id = ?", gameCardId))
}

// GameCardIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdGt(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id > ?", gameCardId))
}

// GameCardIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdGte(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id >= ?", gameCardId))
}

// GameCardIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdIn(gameCardId ...uint32) GameCardLabelQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id IN (?)", gameCardId))
}

// GameCardIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdLt(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id < ?", gameCardId))
}

// GameCardIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdLte(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id <= ?", gameCardId))
}

// GameCardIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdNe(gameCardId uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_card_id != ?", gameCardId))
}

// GameCardIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameCardIdNotIn(gameCardId ...uint32) GameCardLabelQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id NOT IN (?)", gameCardId))
}

// GameLabelEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelEq(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label = ?", gameLabel))
}

// GameLabelGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelGt(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label > ?", gameLabel))
}

// GameLabelGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelGte(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label >= ?", gameLabel))
}

// GameLabelIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelIn(gameLabel ...string) GameCardLabelQuerySet {
	if len(gameLabel) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameLabel in GameLabelIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_label IN (?)", gameLabel))
}

// GameLabelLike is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelLike(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label LIKE ?", gameLabel))
}

// GameLabelLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelLt(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label < ?", gameLabel))
}

// GameLabelLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelLte(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label <= ?", gameLabel))
}

// GameLabelNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelNe(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label != ?", gameLabel))
}

// GameLabelNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelNotIn(gameLabel ...string) GameCardLabelQuerySet {
	if len(gameLabel) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameLabel in GameLabelNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_label NOT IN (?)", gameLabel))
}

// GameLabelNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GameLabelNotlike(gameLabel string) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("game_label NOT LIKE ?", gameLabel))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) GetUpdater() GameCardLabelUpdater {
	return NewGameCardLabelUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDEq(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDGt(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDGte(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDIn(ID ...uint32) GameCardLabelQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDLt(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDLte(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDNe(ID uint32) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) IDNotIn(ID ...uint32) GameCardLabelQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) Limit(limit int) GameCardLabelQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) Offset(offset int) GameCardLabelQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameCardLabelQuerySet) One(ret *GameCardLabel) error {
	return qs.db.First(ret).Error
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByCreatedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByDeletedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByGameCardId() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("game_card_id ASC"))
}

// OrderAscByGameLabel is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByGameLabel() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("game_label ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByID() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderAscByUpdatedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByCreatedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByDeletedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByGameCardId() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("game_card_id DESC"))
}

// OrderDescByGameLabel is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByGameLabel() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("game_label DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByID() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) OrderDescByUpdatedAt() GameCardLabelQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtEq(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtGt(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtGte(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtLt(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtLte(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardLabelQuerySet) UpdatedAtNe(updatedAt time.Time) GameCardLabelQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetCreatedAt(createdAt time.Time) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetDeletedAt(deletedAt *time.Time) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetGameCardId is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetGameCardId(gameCardId uint32) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.GameCardId)] = gameCardId
	return u
}

// SetGameLabel is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetGameLabel(gameLabel string) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.GameLabel)] = gameLabel
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetID(ID uint32) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.ID)] = ID
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) SetUpdatedAt(updatedAt time.Time) GameCardLabelUpdater {
	u.fields[string(GameCardLabelDBSchema.UpdatedAt)] = updatedAt
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameCardLabelUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameCardLabelQuerySet

// ===== BEGIN of GameCardLabel modifiers

// GameCardLabelDBSchemaField describes database schema field. It requires for method 'Update'
type GameCardLabelDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameCardLabelDBSchemaField) String() string {
	return string(f)
}

// GameCardLabelDBSchema stores db field names of GameCardLabel
var GameCardLabelDBSchema = struct {
	ID         GameCardLabelDBSchemaField
	CreatedAt  GameCardLabelDBSchemaField
	UpdatedAt  GameCardLabelDBSchemaField
	DeletedAt  GameCardLabelDBSchemaField
	GameCardId GameCardLabelDBSchemaField
	GameLabel  GameCardLabelDBSchemaField
}{

	ID:         GameCardLabelDBSchemaField("id"),
	CreatedAt:  GameCardLabelDBSchemaField("created_at"),
	UpdatedAt:  GameCardLabelDBSchemaField("updated_at"),
	DeletedAt:  GameCardLabelDBSchemaField("deleted_at"),
	GameCardId: GameCardLabelDBSchemaField("game_card_id"),
	GameLabel:  GameCardLabelDBSchemaField("game_label"),
}

// Update updates GameCardLabel fields by primary key
// nolint: dupl
func (o *GameCardLabel) Update(db *gorm.DB, fields ...GameCardLabelDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":           o.ID,
		"created_at":   o.CreatedAt,
		"updated_at":   o.UpdatedAt,
		"deleted_at":   o.DeletedAt,
		"game_card_id": o.GameCardId,
		"game_label":   o.GameLabel,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameCardLabel %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameCardLabelUpdater is an GameCardLabel updates manager
type GameCardLabelUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameCardLabelUpdater creates new GameCardLabel updater
// nolint: dupl
func NewGameCardLabelUpdater(db *gorm.DB) GameCardLabelUpdater {
	return GameCardLabelUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameCardLabel{}),
	}
}

// ===== END of GameCardLabel modifiers

// ===== BEGIN of query set GameCardQuerySet

// GameCardQuerySet is an queryset type for GameCard
type GameCardQuerySet struct {
	db *gorm.DB
}

// NewGameCardQuerySet constructs new GameCardQuerySet
func NewGameCardQuerySet(db *gorm.DB) GameCardQuerySet {
	return GameCardQuerySet{
		db: db.Model(&GameCard{}),
	}
}

func (qs GameCardQuerySet) w(db *gorm.DB) GameCardQuerySet {
	return NewGameCardQuerySet(db)
}

func (qs GameCardQuerySet) Select(fields ...GameCardDBSchemaField) GameCardQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameCard) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameCard) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) All(ret *[]GameCard) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CoverImgEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgEq(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img = ?", coverImg))
}

// CoverImgGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgGt(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img > ?", coverImg))
}

// CoverImgGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgGte(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img >= ?", coverImg))
}

// CoverImgIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgIn(coverImg ...string) GameCardQuerySet {
	if len(coverImg) == 0 {
		qs.db.AddError(errors.New("must at least pass one coverImg in CoverImgIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("cover_img IN (?)", coverImg))
}

// CoverImgLike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgLike(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img LIKE ?", coverImg))
}

// CoverImgLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgLt(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img < ?", coverImg))
}

// CoverImgLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgLte(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img <= ?", coverImg))
}

// CoverImgNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgNe(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img != ?", coverImg))
}

// CoverImgNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgNotIn(coverImg ...string) GameCardQuerySet {
	if len(coverImg) == 0 {
		qs.db.AddError(errors.New("must at least pass one coverImg in CoverImgNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("cover_img NOT IN (?)", coverImg))
}

// CoverImgNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CoverImgNotlike(coverImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("cover_img NOT LIKE ?", coverImg))
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtEq(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtGt(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtGte(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtLt(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtLte(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) CreatedAtNe(createdAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) Delete() error {
	return qs.db.Delete(GameCard{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameCard{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameCard{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtEq(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtGt(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtGte(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtIsNotNull() GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtIsNull() GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtLt(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtLte(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DeletedAtNe(deletedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// DetailImgEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgEq(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img = ?", detailImg))
}

// DetailImgGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgGt(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img > ?", detailImg))
}

// DetailImgGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgGte(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img >= ?", detailImg))
}

// DetailImgIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgIn(detailImg ...string) GameCardQuerySet {
	if len(detailImg) == 0 {
		qs.db.AddError(errors.New("must at least pass one detailImg in DetailImgIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail_img IN (?)", detailImg))
}

// DetailImgLike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgLike(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img LIKE ?", detailImg))
}

// DetailImgLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgLt(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img < ?", detailImg))
}

// DetailImgLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgLte(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img <= ?", detailImg))
}

// DetailImgNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgNe(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img != ?", detailImg))
}

// DetailImgNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgNotIn(detailImg ...string) GameCardQuerySet {
	if len(detailImg) == 0 {
		qs.db.AddError(errors.New("must at least pass one detailImg in DetailImgNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail_img NOT IN (?)", detailImg))
}

// DetailImgNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailImgNotlike(detailImg string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_img NOT LIKE ?", detailImg))
}

// DetailInfoEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoEq(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info = ?", detailInfo))
}

// DetailInfoGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoGt(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info > ?", detailInfo))
}

// DetailInfoGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoGte(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info >= ?", detailInfo))
}

// DetailInfoIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoIn(detailInfo ...string) GameCardQuerySet {
	if len(detailInfo) == 0 {
		qs.db.AddError(errors.New("must at least pass one detailInfo in DetailInfoIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail_info IN (?)", detailInfo))
}

// DetailInfoLike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoLike(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info LIKE ?", detailInfo))
}

// DetailInfoLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoLt(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info < ?", detailInfo))
}

// DetailInfoLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoLte(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info <= ?", detailInfo))
}

// DetailInfoNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoNe(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info != ?", detailInfo))
}

// DetailInfoNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoNotIn(detailInfo ...string) GameCardQuerySet {
	if len(detailInfo) == 0 {
		qs.db.AddError(errors.New("must at least pass one detailInfo in DetailInfoNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail_info NOT IN (?)", detailInfo))
}

// DetailInfoNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoNotlike(detailInfo string) GameCardQuerySet {
	return qs.w(qs.db.Where("detail_info NOT LIKE ?", detailInfo))
}

// GameTimeEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeEq(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time = ?", gameTime))
}

// GameTimeGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeGt(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time > ?", gameTime))
}

// GameTimeGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeGte(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time >= ?", gameTime))
}

// GameTimeIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeIn(gameTime ...uint32) GameCardQuerySet {
	if len(gameTime) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameTime in GameTimeIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_time IN (?)", gameTime))
}

// GameTimeLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeLt(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time < ?", gameTime))
}

// GameTimeLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeLte(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time <= ?", gameTime))
}

// GameTimeNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeNe(gameTime uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_time != ?", gameTime))
}

// GameTimeNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTimeNotIn(gameTime ...uint32) GameCardQuerySet {
	if len(gameTime) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameTime in GameTimeNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_time NOT IN (?)", gameTime))
}

// GameTypeIdEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdEq(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id = ?", gameTypeId))
}

// GameTypeIdGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdGt(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id > ?", gameTypeId))
}

// GameTypeIdGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdGte(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id >= ?", gameTypeId))
}

// GameTypeIdIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdIn(gameTypeId ...uint32) GameCardQuerySet {
	if len(gameTypeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameTypeId in GameTypeIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_type_id IN (?)", gameTypeId))
}

// GameTypeIdLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdLt(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id < ?", gameTypeId))
}

// GameTypeIdLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdLte(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id <= ?", gameTypeId))
}

// GameTypeIdNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdNe(gameTypeId uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("game_type_id != ?", gameTypeId))
}

// GameTypeIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GameTypeIdNotIn(gameTypeId ...uint32) GameCardQuerySet {
	if len(gameTypeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameTypeId in GameTypeIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_type_id NOT IN (?)", gameTypeId))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GetUpdater() GameCardUpdater {
	return NewGameCardUpdater(qs.db)
}

// GoodsGalleryUrlEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlEq(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url = ?", goodsGalleryUrl))
}

// GoodsGalleryUrlGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlGt(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url > ?", goodsGalleryUrl))
}

// GoodsGalleryUrlGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlGte(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url >= ?", goodsGalleryUrl))
}

// GoodsGalleryUrlIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlIn(goodsGalleryUrl ...string) GameCardQuerySet {
	if len(goodsGalleryUrl) == 0 {
		qs.db.AddError(errors.New("must at least pass one goodsGalleryUrl in GoodsGalleryUrlIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("goods_gallery_url IN (?)", goodsGalleryUrl))
}

// GoodsGalleryUrlLike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlLike(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url LIKE ?", goodsGalleryUrl))
}

// GoodsGalleryUrlLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlLt(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url < ?", goodsGalleryUrl))
}

// GoodsGalleryUrlLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlLte(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url <= ?", goodsGalleryUrl))
}

// GoodsGalleryUrlNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlNe(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url != ?", goodsGalleryUrl))
}

// GoodsGalleryUrlNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlNotIn(goodsGalleryUrl ...string) GameCardQuerySet {
	if len(goodsGalleryUrl) == 0 {
		qs.db.AddError(errors.New("must at least pass one goodsGalleryUrl in GoodsGalleryUrlNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("goods_gallery_url NOT IN (?)", goodsGalleryUrl))
}

// GoodsGalleryUrlNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) GoodsGalleryUrlNotlike(goodsGalleryUrl string) GameCardQuerySet {
	return qs.w(qs.db.Where("goods_gallery_url NOT LIKE ?", goodsGalleryUrl))
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDEq(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDGt(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDGte(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDIn(ID ...uint32) GameCardQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDLt(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDLte(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDNe(ID uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) IDNotIn(ID ...uint32) GameCardQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// LikesEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesEq(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes = ?", likes))
}

// LikesGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesGt(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes > ?", likes))
}

// LikesGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesGte(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes >= ?", likes))
}

// LikesIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesIn(likes ...uint32) GameCardQuerySet {
	if len(likes) == 0 {
		qs.db.AddError(errors.New("must at least pass one likes in LikesIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("likes IN (?)", likes))
}

// LikesLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesLt(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes < ?", likes))
}

// LikesLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesLte(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes <= ?", likes))
}

// LikesNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesNe(likes uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("likes != ?", likes))
}

// LikesNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) LikesNotIn(likes ...uint32) GameCardQuerySet {
	if len(likes) == 0 {
		qs.db.AddError(errors.New("must at least pass one likes in LikesNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("likes NOT IN (?)", likes))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) Limit(limit int) GameCardQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// NameEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameEq(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name = ?", name))
}

// NameGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameGt(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name > ?", name))
}

// NameGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameGte(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name >= ?", name))
}

// NameIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameIn(name ...string) GameCardQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name IN (?)", name))
}

// NameLike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameLike(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name LIKE ?", name))
}

// NameLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameLt(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name < ?", name))
}

// NameLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameLte(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name <= ?", name))
}

// NameNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameNe(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name != ?", name))
}

// NameNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameNotIn(name ...string) GameCardQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name NOT IN (?)", name))
}

// NameNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NameNotlike(name string) GameCardQuerySet {
	return qs.w(qs.db.Where("name NOT LIKE ?", name))
}

// NewProductsEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsEq(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products = ?", newProducts))
}

// NewProductsGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsGt(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products > ?", newProducts))
}

// NewProductsGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsGte(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products >= ?", newProducts))
}

// NewProductsIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsIn(newProducts ...uint8) GameCardQuerySet {
	if len(newProducts) == 0 {
		qs.db.AddError(errors.New("must at least pass one newProducts in NewProductsIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("new_products IN (?)", newProducts))
}

// NewProductsLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsLt(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products < ?", newProducts))
}

// NewProductsLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsLte(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products <= ?", newProducts))
}

// NewProductsNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsNe(newProducts uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("new_products != ?", newProducts))
}

// NewProductsNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) NewProductsNotIn(newProducts ...uint8) GameCardQuerySet {
	if len(newProducts) == 0 {
		qs.db.AddError(errors.New("must at least pass one newProducts in NewProductsNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("new_products NOT IN (?)", newProducts))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) Offset(offset int) GameCardQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameCardQuerySet) One(ret *GameCard) error {
	return qs.db.First(ret).Error
}

// OrderAscByCoverImg is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByCoverImg() GameCardQuerySet {
	return qs.w(qs.db.Order("cover_img ASC"))
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByCreatedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByDeletedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByDetailImg is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByDetailImg() GameCardQuerySet {
	return qs.w(qs.db.Order("detail_img ASC"))
}

// OrderAscByDetailInfo is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByDetailInfo() GameCardQuerySet {
	return qs.w(qs.db.Order("detail_info ASC"))
}

// OrderAscByGameTime is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByGameTime() GameCardQuerySet {
	return qs.w(qs.db.Order("game_time ASC"))
}

// OrderAscByGameTypeId is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByGameTypeId() GameCardQuerySet {
	return qs.w(qs.db.Order("game_type_id ASC"))
}

// OrderAscByGoodsGalleryUrl is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByGoodsGalleryUrl() GameCardQuerySet {
	return qs.w(qs.db.Order("goods_gallery_url ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByID() GameCardQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByLikes is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByLikes() GameCardQuerySet {
	return qs.w(qs.db.Order("likes ASC"))
}

// OrderAscByName is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByName() GameCardQuerySet {
	return qs.w(qs.db.Order("name ASC"))
}

// OrderAscByNewProducts is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByNewProducts() GameCardQuerySet {
	return qs.w(qs.db.Order("new_products ASC"))
}

// OrderAscByOrderCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByOrderCount() GameCardQuerySet {
	return qs.w(qs.db.Order("order_count ASC"))
}

// OrderAscByPlayability is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByPlayability() GameCardQuerySet {
	return qs.w(qs.db.Order("playability ASC"))
}

// OrderAscByPlayfulness is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByPlayfulness() GameCardQuerySet {
	return qs.w(qs.db.Order("playfulness ASC"))
}

// OrderAscByPrice is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByPrice() GameCardQuerySet {
	return qs.w(qs.db.Order("price ASC"))
}

// OrderAscByStatus is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByStatus() GameCardQuerySet {
	return qs.w(qs.db.Order("status ASC"))
}

// OrderAscByStockCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByStockCount() GameCardQuerySet {
	return qs.w(qs.db.Order("stock_count ASC"))
}

// OrderAscByTotalCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByTotalCount() GameCardQuerySet {
	return qs.w(qs.db.Order("total_count ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByUpdatedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderAscByViewCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderAscByViewCount() GameCardQuerySet {
	return qs.w(qs.db.Order("view_count ASC"))
}

// OrderCountEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountEq(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count = ?", orderCount))
}

// OrderCountGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountGt(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count > ?", orderCount))
}

// OrderCountGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountGte(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count >= ?", orderCount))
}

// OrderCountIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountIn(orderCount ...uint32) GameCardQuerySet {
	if len(orderCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one orderCount in OrderCountIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("order_count IN (?)", orderCount))
}

// OrderCountLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountLt(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count < ?", orderCount))
}

// OrderCountLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountLte(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count <= ?", orderCount))
}

// OrderCountNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountNe(orderCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("order_count != ?", orderCount))
}

// OrderCountNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderCountNotIn(orderCount ...uint32) GameCardQuerySet {
	if len(orderCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one orderCount in OrderCountNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("order_count NOT IN (?)", orderCount))
}

// OrderDescByCoverImg is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByCoverImg() GameCardQuerySet {
	return qs.w(qs.db.Order("cover_img DESC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByCreatedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByDeletedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByDetailImg is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByDetailImg() GameCardQuerySet {
	return qs.w(qs.db.Order("detail_img DESC"))
}

// OrderDescByDetailInfo is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByDetailInfo() GameCardQuerySet {
	return qs.w(qs.db.Order("detail_info DESC"))
}

// OrderDescByGameTime is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByGameTime() GameCardQuerySet {
	return qs.w(qs.db.Order("game_time DESC"))
}

// OrderDescByGameTypeId is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByGameTypeId() GameCardQuerySet {
	return qs.w(qs.db.Order("game_type_id DESC"))
}

// OrderDescByGoodsGalleryUrl is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByGoodsGalleryUrl() GameCardQuerySet {
	return qs.w(qs.db.Order("goods_gallery_url DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByID() GameCardQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByLikes is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByLikes() GameCardQuerySet {
	return qs.w(qs.db.Order("likes DESC"))
}

// OrderDescByName is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByName() GameCardQuerySet {
	return qs.w(qs.db.Order("name DESC"))
}

// OrderDescByNewProducts is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByNewProducts() GameCardQuerySet {
	return qs.w(qs.db.Order("new_products DESC"))
}

// OrderDescByOrderCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByOrderCount() GameCardQuerySet {
	return qs.w(qs.db.Order("order_count DESC"))
}

// OrderDescByPlayability is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByPlayability() GameCardQuerySet {
	return qs.w(qs.db.Order("playability DESC"))
}

// OrderDescByPlayfulness is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByPlayfulness() GameCardQuerySet {
	return qs.w(qs.db.Order("playfulness DESC"))
}

// OrderDescByPrice is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByPrice() GameCardQuerySet {
	return qs.w(qs.db.Order("price DESC"))
}

// OrderDescByStatus is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByStatus() GameCardQuerySet {
	return qs.w(qs.db.Order("status DESC"))
}

// OrderDescByStockCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByStockCount() GameCardQuerySet {
	return qs.w(qs.db.Order("stock_count DESC"))
}

// OrderDescByTotalCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByTotalCount() GameCardQuerySet {
	return qs.w(qs.db.Order("total_count DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByUpdatedAt() GameCardQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// OrderDescByViewCount is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) OrderDescByViewCount() GameCardQuerySet {
	return qs.w(qs.db.Order("view_count DESC"))
}

// PlayabilityEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityEq(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability = ?", playability))
}

// PlayabilityGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityGt(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability > ?", playability))
}

// PlayabilityGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityGte(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability >= ?", playability))
}

// PlayabilityIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityIn(playability ...uint32) GameCardQuerySet {
	if len(playability) == 0 {
		qs.db.AddError(errors.New("must at least pass one playability in PlayabilityIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("playability IN (?)", playability))
}

// PlayabilityLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityLt(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability < ?", playability))
}

// PlayabilityLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityLte(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability <= ?", playability))
}

// PlayabilityNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityNe(playability uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playability != ?", playability))
}

// PlayabilityNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayabilityNotIn(playability ...uint32) GameCardQuerySet {
	if len(playability) == 0 {
		qs.db.AddError(errors.New("must at least pass one playability in PlayabilityNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("playability NOT IN (?)", playability))
}

// PlayfulnessEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessEq(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness = ?", playfulness))
}

// PlayfulnessGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessGt(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness > ?", playfulness))
}

// PlayfulnessGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessGte(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness >= ?", playfulness))
}

// PlayfulnessIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessIn(playfulness ...uint32) GameCardQuerySet {
	if len(playfulness) == 0 {
		qs.db.AddError(errors.New("must at least pass one playfulness in PlayfulnessIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("playfulness IN (?)", playfulness))
}

// PlayfulnessLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessLt(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness < ?", playfulness))
}

// PlayfulnessLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessLte(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness <= ?", playfulness))
}

// PlayfulnessNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessNe(playfulness uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("playfulness != ?", playfulness))
}

// PlayfulnessNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PlayfulnessNotIn(playfulness ...uint32) GameCardQuerySet {
	if len(playfulness) == 0 {
		qs.db.AddError(errors.New("must at least pass one playfulness in PlayfulnessNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("playfulness NOT IN (?)", playfulness))
}

// PriceEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceEq(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price = ?", price))
}

// PriceGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceGt(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price > ?", price))
}

// PriceGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceGte(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price >= ?", price))
}

// PriceIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceIn(price ...uint32) GameCardQuerySet {
	if len(price) == 0 {
		qs.db.AddError(errors.New("must at least pass one price in PriceIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("price IN (?)", price))
}

// PriceLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceLt(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price < ?", price))
}

// PriceLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceLte(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price <= ?", price))
}

// PriceNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceNe(price uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("price != ?", price))
}

// PriceNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) PriceNotIn(price ...uint32) GameCardQuerySet {
	if len(price) == 0 {
		qs.db.AddError(errors.New("must at least pass one price in PriceNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("price NOT IN (?)", price))
}

// StatusEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusEq(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status = ?", status))
}

// StatusGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusGt(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status > ?", status))
}

// StatusGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusGte(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status >= ?", status))
}

// StatusIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusIn(status ...uint8) GameCardQuerySet {
	if len(status) == 0 {
		qs.db.AddError(errors.New("must at least pass one status in StatusIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("status IN (?)", status))
}

// StatusLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusLt(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status < ?", status))
}

// StatusLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusLte(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status <= ?", status))
}

// StatusNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusNe(status uint8) GameCardQuerySet {
	return qs.w(qs.db.Where("status != ?", status))
}

// StatusNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StatusNotIn(status ...uint8) GameCardQuerySet {
	if len(status) == 0 {
		qs.db.AddError(errors.New("must at least pass one status in StatusNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("status NOT IN (?)", status))
}

// StockCountEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountEq(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count = ?", stockCount))
}

// StockCountGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountGt(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count > ?", stockCount))
}

// StockCountGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountGte(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count >= ?", stockCount))
}

// StockCountIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountIn(stockCount ...uint32) GameCardQuerySet {
	if len(stockCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one stockCount in StockCountIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("stock_count IN (?)", stockCount))
}

// StockCountLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountLt(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count < ?", stockCount))
}

// StockCountLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountLte(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count <= ?", stockCount))
}

// StockCountNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountNe(stockCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("stock_count != ?", stockCount))
}

// StockCountNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) StockCountNotIn(stockCount ...uint32) GameCardQuerySet {
	if len(stockCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one stockCount in StockCountNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("stock_count NOT IN (?)", stockCount))
}

// TotalCountEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountEq(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count = ?", totalCount))
}

// TotalCountGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountGt(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count > ?", totalCount))
}

// TotalCountGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountGte(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count >= ?", totalCount))
}

// TotalCountIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountIn(totalCount ...uint32) GameCardQuerySet {
	if len(totalCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one totalCount in TotalCountIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("total_count IN (?)", totalCount))
}

// TotalCountLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountLt(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count < ?", totalCount))
}

// TotalCountLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountLte(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count <= ?", totalCount))
}

// TotalCountNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountNe(totalCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("total_count != ?", totalCount))
}

// TotalCountNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) TotalCountNotIn(totalCount ...uint32) GameCardQuerySet {
	if len(totalCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one totalCount in TotalCountNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("total_count NOT IN (?)", totalCount))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtEq(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtGt(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtGte(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtLt(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtLte(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) UpdatedAtNe(updatedAt time.Time) GameCardQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// ViewCountEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountEq(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count = ?", viewCount))
}

// ViewCountGt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountGt(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count > ?", viewCount))
}

// ViewCountGte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountGte(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count >= ?", viewCount))
}

// ViewCountIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountIn(viewCount ...uint32) GameCardQuerySet {
	if len(viewCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one viewCount in ViewCountIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("view_count IN (?)", viewCount))
}

// ViewCountLt is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountLt(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count < ?", viewCount))
}

// ViewCountLte is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountLte(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count <= ?", viewCount))
}

// ViewCountNe is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountNe(viewCount uint32) GameCardQuerySet {
	return qs.w(qs.db.Where("view_count != ?", viewCount))
}

// ViewCountNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) ViewCountNotIn(viewCount ...uint32) GameCardQuerySet {
	if len(viewCount) == 0 {
		qs.db.AddError(errors.New("must at least pass one viewCount in ViewCountNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("view_count NOT IN (?)", viewCount))
}

// SetCoverImg is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetCoverImg(coverImg string) GameCardUpdater {
	u.fields[string(GameCardDBSchema.CoverImg)] = coverImg
	return u
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetCreatedAt(createdAt time.Time) GameCardUpdater {
	u.fields[string(GameCardDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetDeletedAt(deletedAt *time.Time) GameCardUpdater {
	u.fields[string(GameCardDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetDetailImg is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetDetailImg(detailImg string) GameCardUpdater {
	u.fields[string(GameCardDBSchema.DetailImg)] = detailImg
	return u
}

// SetDetailInfo is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetDetailInfo(detailInfo string) GameCardUpdater {
	u.fields[string(GameCardDBSchema.DetailInfo)] = detailInfo
	return u
}

// SetGameTime is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetGameTime(gameTime uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.GameTime)] = gameTime
	return u
}

// SetGameTypeId is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetGameTypeId(gameTypeId uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.GameTypeId)] = gameTypeId
	return u
}

// SetGoodsGalleryUrl is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetGoodsGalleryUrl(goodsGalleryUrl string) GameCardUpdater {
	u.fields[string(GameCardDBSchema.GoodsGalleryUrl)] = goodsGalleryUrl
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetID(ID uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.ID)] = ID
	return u
}

// SetLikes is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetLikes(likes uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Likes)] = likes
	return u
}

// SetName is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetName(name string) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Name)] = name
	return u
}

// SetNewProducts is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetNewProducts(newProducts uint8) GameCardUpdater {
	u.fields[string(GameCardDBSchema.NewProducts)] = newProducts
	return u
}

// SetOrderCount is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetOrderCount(orderCount uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.OrderCount)] = orderCount
	return u
}

// SetPlayability is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetPlayability(playability uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Playability)] = playability
	return u
}

// SetPlayfulness is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetPlayfulness(playfulness uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Playfulness)] = playfulness
	return u
}

// SetPrice is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetPrice(price uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Price)] = price
	return u
}

// SetStatus is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetStatus(status uint8) GameCardUpdater {
	u.fields[string(GameCardDBSchema.Status)] = status
	return u
}

// SetStockCount is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetStockCount(stockCount uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.StockCount)] = stockCount
	return u
}

// SetTotalCount is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetTotalCount(totalCount uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.TotalCount)] = totalCount
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetUpdatedAt(updatedAt time.Time) GameCardUpdater {
	u.fields[string(GameCardDBSchema.UpdatedAt)] = updatedAt
	return u
}

// SetViewCount is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) SetViewCount(viewCount uint32) GameCardUpdater {
	u.fields[string(GameCardDBSchema.ViewCount)] = viewCount
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameCardUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameCardQuerySet

// ===== BEGIN of GameCard modifiers

// GameCardDBSchemaField describes database schema field. It requires for method 'Update'
type GameCardDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameCardDBSchemaField) String() string {
	return string(f)
}

// GameCardDBSchema stores db field names of GameCard
var GameCardDBSchema = struct {
	ID              GameCardDBSchemaField
	CreatedAt       GameCardDBSchemaField
	UpdatedAt       GameCardDBSchemaField
	DeletedAt       GameCardDBSchemaField
	Name            GameCardDBSchemaField
	Price           GameCardDBSchemaField
	CoverImg        GameCardDBSchemaField
	OrderCount      GameCardDBSchemaField
	NewProducts     GameCardDBSchemaField
	Status          GameCardDBSchemaField
	StockCount      GameCardDBSchemaField
	TotalCount      GameCardDBSchemaField
	GameTypeId      GameCardDBSchemaField
	GoodsGalleryUrl GameCardDBSchemaField
	ViewCount       GameCardDBSchemaField
	Playability     GameCardDBSchemaField
	Playfulness     GameCardDBSchemaField
	GameTime        GameCardDBSchemaField
	Likes           GameCardDBSchemaField
	DetailInfo      GameCardDBSchemaField
	DetailImg       GameCardDBSchemaField
}{

	ID:              GameCardDBSchemaField("id"),
	CreatedAt:       GameCardDBSchemaField("created_at"),
	UpdatedAt:       GameCardDBSchemaField("updated_at"),
	DeletedAt:       GameCardDBSchemaField("deleted_at"),
	Name:            GameCardDBSchemaField("name"),
	Price:           GameCardDBSchemaField("price"),
	CoverImg:        GameCardDBSchemaField("cover_img"),
	OrderCount:      GameCardDBSchemaField("order_count"),
	NewProducts:     GameCardDBSchemaField("new_products"),
	Status:          GameCardDBSchemaField("status"),
	StockCount:      GameCardDBSchemaField("stock_count"),
	TotalCount:      GameCardDBSchemaField("total_count"),
	GameTypeId:      GameCardDBSchemaField("game_type_id"),
	GoodsGalleryUrl: GameCardDBSchemaField("goods_gallery_url"),
	ViewCount:       GameCardDBSchemaField("view_count"),
	Playability:     GameCardDBSchemaField("playability"),
	Playfulness:     GameCardDBSchemaField("playfulness"),
	GameTime:        GameCardDBSchemaField("game_time"),
	Likes:           GameCardDBSchemaField("likes"),
	DetailInfo:      GameCardDBSchemaField("detail_info"),
	DetailImg:       GameCardDBSchemaField("detail_img"),
}

// Update updates GameCard fields by primary key
// nolint: dupl
func (o *GameCard) Update(db *gorm.DB, fields ...GameCardDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":                o.ID,
		"created_at":        o.CreatedAt,
		"updated_at":        o.UpdatedAt,
		"deleted_at":        o.DeletedAt,
		"name":              o.Name,
		"price":             o.Price,
		"cover_img":         o.CoverImg,
		"order_count":       o.OrderCount,
		"new_products":      o.NewProducts,
		"status":            o.Status,
		"stock_count":       o.StockCount,
		"total_count":       o.TotalCount,
		"game_type_id":      o.GameTypeId,
		"goods_gallery_url": o.GoodsGalleryUrl,
		"view_count":        o.ViewCount,
		"playability":       o.Playability,
		"playfulness":       o.Playfulness,
		"game_time":         o.GameTime,
		"likes":             o.Likes,
		"detail_info":       o.DetailInfo,
		"detail_img":        o.DetailImg,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameCard %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameCardUpdater is an GameCard updates manager
type GameCardUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameCardUpdater creates new GameCard updater
// nolint: dupl
func NewGameCardUpdater(db *gorm.DB) GameCardUpdater {
	return GameCardUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameCard{}),
	}
}

// ===== END of GameCard modifiers

// ===== BEGIN of query set GameCardTypeQuerySet

// GameCardTypeQuerySet is an queryset type for GameCardType
type GameCardTypeQuerySet struct {
	db *gorm.DB
}

// NewGameCardTypeQuerySet constructs new GameCardTypeQuerySet
func NewGameCardTypeQuerySet(db *gorm.DB) GameCardTypeQuerySet {
	return GameCardTypeQuerySet{
		db: db.Model(&GameCardType{}),
	}
}

func (qs GameCardTypeQuerySet) w(db *gorm.DB) GameCardTypeQuerySet {
	return NewGameCardTypeQuerySet(db)
}

func (qs GameCardTypeQuerySet) Select(fields ...GameCardTypeDBSchemaField) GameCardTypeQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameCardType) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameCardType) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) All(ret *[]GameCardType) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtEq(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtGt(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtGte(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtLt(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtLte(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) CreatedAtNe(createdAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) Delete() error {
	return qs.db.Delete(GameCardType{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameCardType{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameCardType{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtEq(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtGt(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtGte(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtIsNotNull() GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtIsNull() GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtLt(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtLte(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) DeletedAtNe(deletedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) GetUpdater() GameCardTypeUpdater {
	return NewGameCardTypeUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDEq(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDGt(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDGte(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDIn(ID ...uint32) GameCardTypeQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDLt(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDLte(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDNe(ID uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) IDNotIn(ID ...uint32) GameCardTypeQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) Limit(limit int) GameCardTypeQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// NameEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameEq(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name = ?", name))
}

// NameGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameGt(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name > ?", name))
}

// NameGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameGte(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name >= ?", name))
}

// NameIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameIn(name ...string) GameCardTypeQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name IN (?)", name))
}

// NameLike is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameLike(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name LIKE ?", name))
}

// NameLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameLt(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name < ?", name))
}

// NameLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameLte(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name <= ?", name))
}

// NameNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameNe(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name != ?", name))
}

// NameNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameNotIn(name ...string) GameCardTypeQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name NOT IN (?)", name))
}

// NameNotlike is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) NameNotlike(name string) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("name NOT LIKE ?", name))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) Offset(offset int) GameCardTypeQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameCardTypeQuerySet) One(ret *GameCardType) error {
	return qs.db.First(ret).Error
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscByCreatedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscByDeletedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscByID() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByName is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscByName() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("name ASC"))
}

// OrderAscBySort is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscBySort() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("sort ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderAscByUpdatedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescByCreatedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescByDeletedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescByID() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByName is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescByName() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("name DESC"))
}

// OrderDescBySort is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescBySort() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("sort DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) OrderDescByUpdatedAt() GameCardTypeQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// SortEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortEq(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort = ?", sort))
}

// SortGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortGt(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort > ?", sort))
}

// SortGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortGte(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort >= ?", sort))
}

// SortIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortIn(sort ...uint32) GameCardTypeQuerySet {
	if len(sort) == 0 {
		qs.db.AddError(errors.New("must at least pass one sort in SortIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("sort IN (?)", sort))
}

// SortLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortLt(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort < ?", sort))
}

// SortLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortLte(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort <= ?", sort))
}

// SortNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortNe(sort uint32) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("sort != ?", sort))
}

// SortNotIn is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) SortNotIn(sort ...uint32) GameCardTypeQuerySet {
	if len(sort) == 0 {
		qs.db.AddError(errors.New("must at least pass one sort in SortNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("sort NOT IN (?)", sort))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtEq(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtGt(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtGte(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtLt(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtLte(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameCardTypeQuerySet) UpdatedAtNe(updatedAt time.Time) GameCardTypeQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetCreatedAt(createdAt time.Time) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetDeletedAt(deletedAt *time.Time) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetID(ID uint32) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.ID)] = ID
	return u
}

// SetName is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetName(name string) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.Name)] = name
	return u
}

// SetSort is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetSort(sort uint32) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.Sort)] = sort
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) SetUpdatedAt(updatedAt time.Time) GameCardTypeUpdater {
	u.fields[string(GameCardTypeDBSchema.UpdatedAt)] = updatedAt
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameCardTypeUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameCardTypeQuerySet

// ===== BEGIN of GameCardType modifiers

// GameCardTypeDBSchemaField describes database schema field. It requires for method 'Update'
type GameCardTypeDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameCardTypeDBSchemaField) String() string {
	return string(f)
}

// GameCardTypeDBSchema stores db field names of GameCardType
var GameCardTypeDBSchema = struct {
	ID        GameCardTypeDBSchemaField
	CreatedAt GameCardTypeDBSchemaField
	UpdatedAt GameCardTypeDBSchemaField
	DeletedAt GameCardTypeDBSchemaField
	Name      GameCardTypeDBSchemaField
	Sort      GameCardTypeDBSchemaField
}{

	ID:        GameCardTypeDBSchemaField("id"),
	CreatedAt: GameCardTypeDBSchemaField("created_at"),
	UpdatedAt: GameCardTypeDBSchemaField("updated_at"),
	DeletedAt: GameCardTypeDBSchemaField("deleted_at"),
	Name:      GameCardTypeDBSchemaField("name"),
	Sort:      GameCardTypeDBSchemaField("sort"),
}

// Update updates GameCardType fields by primary key
// nolint: dupl
func (o *GameCardType) Update(db *gorm.DB, fields ...GameCardTypeDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":         o.ID,
		"created_at": o.CreatedAt,
		"updated_at": o.UpdatedAt,
		"deleted_at": o.DeletedAt,
		"name":       o.Name,
		"sort":       o.Sort,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameCardType %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameCardTypeUpdater is an GameCardType updates manager
type GameCardTypeUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameCardTypeUpdater creates new GameCardType updater
// nolint: dupl
func NewGameCardTypeUpdater(db *gorm.DB) GameCardTypeUpdater {
	return GameCardTypeUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameCardType{}),
	}
}

// ===== END of GameCardType modifiers

// ===== BEGIN of query set GameTypeQuerySet

// GameTypeQuerySet is an queryset type for GameType
type GameTypeQuerySet struct {
	db *gorm.DB
}

// NewGameTypeQuerySet constructs new GameTypeQuerySet
func NewGameTypeQuerySet(db *gorm.DB) GameTypeQuerySet {
	return GameTypeQuerySet{
		db: db.Model(&GameType{}),
	}
}

func (qs GameTypeQuerySet) w(db *gorm.DB) GameTypeQuerySet {
	return NewGameTypeQuerySet(db)
}

func (qs GameTypeQuerySet) Select(fields ...GameTypeDBSchemaField) GameTypeQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *GameType) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *GameType) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) All(ret *[]GameType) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtEq(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtGt(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtGte(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtLt(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtLte(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) CreatedAtNe(createdAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) Delete() error {
	return qs.db.Delete(GameType{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(GameType{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(GameType{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtEq(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtGt(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtGte(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtIsNotNull() GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtIsNull() GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtLt(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtLte(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) DeletedAtNe(deletedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// GameCardIdEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdEq(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id = ?", gameCardId))
}

// GameCardIdGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdGt(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id > ?", gameCardId))
}

// GameCardIdGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdGte(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id >= ?", gameCardId))
}

// GameCardIdIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdIn(gameCardId ...uint64) GameTypeQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id IN (?)", gameCardId))
}

// GameCardIdLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdLt(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id < ?", gameCardId))
}

// GameCardIdLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdLte(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id <= ?", gameCardId))
}

// GameCardIdNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdNe(gameCardId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_id != ?", gameCardId))
}

// GameCardIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardIdNotIn(gameCardId ...uint64) GameTypeQuerySet {
	if len(gameCardId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardId in GameCardIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_id NOT IN (?)", gameCardId))
}

// GameCardTypeIdEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdEq(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id = ?", gameCardTypeId))
}

// GameCardTypeIdGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdGt(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id > ?", gameCardTypeId))
}

// GameCardTypeIdGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdGte(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id >= ?", gameCardTypeId))
}

// GameCardTypeIdIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdIn(gameCardTypeId ...uint64) GameTypeQuerySet {
	if len(gameCardTypeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardTypeId in GameCardTypeIdIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_type_id IN (?)", gameCardTypeId))
}

// GameCardTypeIdLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdLt(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id < ?", gameCardTypeId))
}

// GameCardTypeIdLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdLte(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id <= ?", gameCardTypeId))
}

// GameCardTypeIdNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdNe(gameCardTypeId uint64) GameTypeQuerySet {
	return qs.w(qs.db.Where("game_card_type_id != ?", gameCardTypeId))
}

// GameCardTypeIdNotIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GameCardTypeIdNotIn(gameCardTypeId ...uint64) GameTypeQuerySet {
	if len(gameCardTypeId) == 0 {
		qs.db.AddError(errors.New("must at least pass one gameCardTypeId in GameCardTypeIdNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("game_card_type_id NOT IN (?)", gameCardTypeId))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) GetUpdater() GameTypeUpdater {
	return NewGameTypeUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDEq(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDGt(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDGte(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDIn(ID ...uint32) GameTypeQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDLt(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDLte(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDNe(ID uint32) GameTypeQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) IDNotIn(ID ...uint32) GameTypeQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) Limit(limit int) GameTypeQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) Offset(offset int) GameTypeQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs GameTypeQuerySet) One(ret *GameType) error {
	return qs.db.First(ret).Error
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByCreatedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByDeletedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByGameCardId() GameTypeQuerySet {
	return qs.w(qs.db.Order("game_card_id ASC"))
}

// OrderAscByGameCardTypeId is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByGameCardTypeId() GameTypeQuerySet {
	return qs.w(qs.db.Order("game_card_type_id ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByID() GameTypeQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderAscByUpdatedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByCreatedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByDeletedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByGameCardId is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByGameCardId() GameTypeQuerySet {
	return qs.w(qs.db.Order("game_card_id DESC"))
}

// OrderDescByGameCardTypeId is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByGameCardTypeId() GameTypeQuerySet {
	return qs.w(qs.db.Order("game_card_type_id DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByID() GameTypeQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) OrderDescByUpdatedAt() GameTypeQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtEq(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtGt(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtGte(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtLt(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtLte(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs GameTypeQuerySet) UpdatedAtNe(updatedAt time.Time) GameTypeQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetCreatedAt(createdAt time.Time) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetDeletedAt(deletedAt *time.Time) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetGameCardId is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetGameCardId(gameCardId uint64) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.GameCardId)] = gameCardId
	return u
}

// SetGameCardTypeId is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetGameCardTypeId(gameCardTypeId uint64) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.GameCardTypeId)] = gameCardTypeId
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetID(ID uint32) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.ID)] = ID
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) SetUpdatedAt(updatedAt time.Time) GameTypeUpdater {
	u.fields[string(GameTypeDBSchema.UpdatedAt)] = updatedAt
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u GameTypeUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set GameTypeQuerySet

// ===== BEGIN of GameType modifiers

// GameTypeDBSchemaField describes database schema field. It requires for method 'Update'
type GameTypeDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f GameTypeDBSchemaField) String() string {
	return string(f)
}

// GameTypeDBSchema stores db field names of GameType
var GameTypeDBSchema = struct {
	ID             GameTypeDBSchemaField
	CreatedAt      GameTypeDBSchemaField
	UpdatedAt      GameTypeDBSchemaField
	DeletedAt      GameTypeDBSchemaField
	GameCardId     GameTypeDBSchemaField
	GameCardTypeId GameTypeDBSchemaField
}{

	ID:             GameTypeDBSchemaField("id"),
	CreatedAt:      GameTypeDBSchemaField("created_at"),
	UpdatedAt:      GameTypeDBSchemaField("updated_at"),
	DeletedAt:      GameTypeDBSchemaField("deleted_at"),
	GameCardId:     GameTypeDBSchemaField("game_card_id"),
	GameCardTypeId: GameTypeDBSchemaField("game_card_type_id"),
}

// Update updates GameType fields by primary key
// nolint: dupl
func (o *GameType) Update(db *gorm.DB, fields ...GameTypeDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":                o.ID,
		"created_at":        o.CreatedAt,
		"updated_at":        o.UpdatedAt,
		"deleted_at":        o.DeletedAt,
		"game_card_id":      o.GameCardId,
		"game_card_type_id": o.GameCardTypeId,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update GameType %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// GameTypeUpdater is an GameType updates manager
type GameTypeUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewGameTypeUpdater creates new GameType updater
// nolint: dupl
func NewGameTypeUpdater(db *gorm.DB) GameTypeUpdater {
	return GameTypeUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&GameType{}),
	}
}

// ===== END of GameType modifiers

// ===== BEGIN of query set HomeCarouselQuerySet

// HomeCarouselQuerySet is an queryset type for HomeCarousel
type HomeCarouselQuerySet struct {
	db *gorm.DB
}

// NewHomeCarouselQuerySet constructs new HomeCarouselQuerySet
func NewHomeCarouselQuerySet(db *gorm.DB) HomeCarouselQuerySet {
	return HomeCarouselQuerySet{
		db: db.Model(&HomeCarousel{}),
	}
}

func (qs HomeCarouselQuerySet) w(db *gorm.DB) HomeCarouselQuerySet {
	return NewHomeCarouselQuerySet(db)
}

func (qs HomeCarouselQuerySet) Select(fields ...HomeCarouselDBSchemaField) HomeCarouselQuerySet {
	names := []string{}
	for _, f := range fields {
		names = append(names, f.String())
	}

	return qs.w(qs.db.Select(strings.Join(names, ",")))
}

// Create is an autogenerated method
// nolint: dupl
func (o *HomeCarousel) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

// Delete is an autogenerated method
// nolint: dupl
func (o *HomeCarousel) Delete(db *gorm.DB) error {
	return db.Delete(o).Error
}

// All is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) All(ret *[]HomeCarousel) error {
	return qs.db.Find(ret).Error
}

// Count is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) Count() (int, error) {
	var count int
	err := qs.db.Count(&count).Error
	return count, err
}

// CreatedAtEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtEq(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at = ?", createdAt))
}

// CreatedAtGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtGt(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at > ?", createdAt))
}

// CreatedAtGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtGte(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at >= ?", createdAt))
}

// CreatedAtLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtLt(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at < ?", createdAt))
}

// CreatedAtLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtLte(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at <= ?", createdAt))
}

// CreatedAtNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) CreatedAtNe(createdAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("created_at != ?", createdAt))
}

// Delete is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) Delete() error {
	return qs.db.Delete(HomeCarousel{}).Error
}

// DeleteNum is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeleteNum() (int64, error) {
	db := qs.db.Delete(HomeCarousel{})
	return db.RowsAffected, db.Error
}

// DeleteNumUnscoped is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeleteNumUnscoped() (int64, error) {
	db := qs.db.Unscoped().Delete(HomeCarousel{})
	return db.RowsAffected, db.Error
}

// DeletedAtEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtEq(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at = ?", deletedAt))
}

// DeletedAtGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtGt(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at > ?", deletedAt))
}

// DeletedAtGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtGte(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at >= ?", deletedAt))
}

// DeletedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtIsNotNull() HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NOT NULL"))
}

// DeletedAtIsNull is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtIsNull() HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at IS NULL"))
}

// DeletedAtLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtLt(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at < ?", deletedAt))
}

// DeletedAtLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtLte(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at <= ?", deletedAt))
}

// DeletedAtNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DeletedAtNe(deletedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("deleted_at != ?", deletedAt))
}

// DetailEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailEq(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail = ?", detail))
}

// DetailGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailGt(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail > ?", detail))
}

// DetailGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailGte(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail >= ?", detail))
}

// DetailIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailIn(detail ...string) HomeCarouselQuerySet {
	if len(detail) == 0 {
		qs.db.AddError(errors.New("must at least pass one detail in DetailIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail IN (?)", detail))
}

// DetailLike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailLike(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail LIKE ?", detail))
}

// DetailLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailLt(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail < ?", detail))
}

// DetailLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailLte(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail <= ?", detail))
}

// DetailNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailNe(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail != ?", detail))
}

// DetailNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailNotIn(detail ...string) HomeCarouselQuerySet {
	if len(detail) == 0 {
		qs.db.AddError(errors.New("must at least pass one detail in DetailNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("detail NOT IN (?)", detail))
}

// DetailNotlike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) DetailNotlike(detail string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("detail NOT LIKE ?", detail))
}

// GetDB is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) GetDB() *gorm.DB {
	return qs.db
}

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) GetUpdater() HomeCarouselUpdater {
	return NewHomeCarouselUpdater(qs.db)
}

// IDEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDEq(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id = ?", ID))
}

// IDGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDGt(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id > ?", ID))
}

// IDGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDGte(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id >= ?", ID))
}

// IDIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDIn(ID ...uint32) HomeCarouselQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id IN (?)", ID))
}

// IDLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDLt(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

// IDLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDLte(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id <= ?", ID))
}

// IDNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDNe(ID uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("id != ?", ID))
}

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IDNotIn(ID ...uint32) HomeCarouselQuerySet {
	if len(ID) == 0 {
		qs.db.AddError(errors.New("must at least pass one ID in IDNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("id NOT IN (?)", ID))
}

// ImgEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgEq(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img = ?", img))
}

// ImgGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgGt(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img > ?", img))
}

// ImgGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgGte(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img >= ?", img))
}

// ImgIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgIn(img ...string) HomeCarouselQuerySet {
	if len(img) == 0 {
		qs.db.AddError(errors.New("must at least pass one img in ImgIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("img IN (?)", img))
}

// ImgLike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgLike(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img LIKE ?", img))
}

// ImgLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgLt(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img < ?", img))
}

// ImgLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgLte(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img <= ?", img))
}

// ImgNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgNe(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img != ?", img))
}

// ImgNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgNotIn(img ...string) HomeCarouselQuerySet {
	if len(img) == 0 {
		qs.db.AddError(errors.New("must at least pass one img in ImgNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("img NOT IN (?)", img))
}

// ImgNotlike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) ImgNotlike(img string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("img NOT LIKE ?", img))
}

// IsShowEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowEq(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show = ?", isShow))
}

// IsShowGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowGt(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show > ?", isShow))
}

// IsShowGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowGte(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show >= ?", isShow))
}

// IsShowIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowIn(isShow ...uint32) HomeCarouselQuerySet {
	if len(isShow) == 0 {
		qs.db.AddError(errors.New("must at least pass one isShow in IsShowIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("is_show IN (?)", isShow))
}

// IsShowLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowLt(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show < ?", isShow))
}

// IsShowLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowLte(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show <= ?", isShow))
}

// IsShowNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowNe(isShow uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("is_show != ?", isShow))
}

// IsShowNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) IsShowNotIn(isShow ...uint32) HomeCarouselQuerySet {
	if len(isShow) == 0 {
		qs.db.AddError(errors.New("must at least pass one isShow in IsShowNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("is_show NOT IN (?)", isShow))
}

// Limit is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) Limit(limit int) HomeCarouselQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// LinkEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkEq(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link = ?", link))
}

// LinkGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkGt(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link > ?", link))
}

// LinkGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkGte(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link >= ?", link))
}

// LinkIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkIn(link ...string) HomeCarouselQuerySet {
	if len(link) == 0 {
		qs.db.AddError(errors.New("must at least pass one link in LinkIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("link IN (?)", link))
}

// LinkLike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkLike(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link LIKE ?", link))
}

// LinkLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkLt(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link < ?", link))
}

// LinkLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkLte(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link <= ?", link))
}

// LinkNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkNe(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link != ?", link))
}

// LinkNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkNotIn(link ...string) HomeCarouselQuerySet {
	if len(link) == 0 {
		qs.db.AddError(errors.New("must at least pass one link in LinkNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("link NOT IN (?)", link))
}

// LinkNotlike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) LinkNotlike(link string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("link NOT LIKE ?", link))
}

// NameEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameEq(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name = ?", name))
}

// NameGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameGt(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name > ?", name))
}

// NameGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameGte(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name >= ?", name))
}

// NameIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameIn(name ...string) HomeCarouselQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name IN (?)", name))
}

// NameLike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameLike(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name LIKE ?", name))
}

// NameLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameLt(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name < ?", name))
}

// NameLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameLte(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name <= ?", name))
}

// NameNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameNe(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name != ?", name))
}

// NameNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameNotIn(name ...string) HomeCarouselQuerySet {
	if len(name) == 0 {
		qs.db.AddError(errors.New("must at least pass one name in NameNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("name NOT IN (?)", name))
}

// NameNotlike is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameNotlike(name string) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("name NOT LIKE ?", name))
}

// Offset is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) Offset(offset int) HomeCarouselQuerySet {
	return qs.w(qs.db.Offset(offset))
}

// One is used to retrieve one result. It returns gorm.ErrRecordNotFound
// if nothing was fetched
func (qs HomeCarouselQuerySet) One(ret *HomeCarousel) error {
	return qs.db.First(ret).Error
}

// OrderAscByCreatedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByCreatedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("created_at ASC"))
}

// OrderAscByDeletedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByDeletedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("deleted_at ASC"))
}

// OrderAscByDetail is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByDetail() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("detail ASC"))
}

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByID() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("id ASC"))
}

// OrderAscByImg is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByImg() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("img ASC"))
}

// OrderAscByIsShow is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByIsShow() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("is_show ASC"))
}

// OrderAscByLink is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByLink() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("link ASC"))
}

// OrderAscByName is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByName() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("name ASC"))
}

// OrderAscBySort is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscBySort() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("sort ASC"))
}

// OrderAscByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByUpdatedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("updated_at ASC"))
}

// OrderDescByCreatedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByCreatedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("created_at DESC"))
}

// OrderDescByDeletedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByDeletedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("deleted_at DESC"))
}

// OrderDescByDetail is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByDetail() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("detail DESC"))
}

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByID() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("id DESC"))
}

// OrderDescByImg is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByImg() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("img DESC"))
}

// OrderDescByIsShow is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByIsShow() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("is_show DESC"))
}

// OrderDescByLink is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByLink() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("link DESC"))
}

// OrderDescByName is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByName() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("name DESC"))
}

// OrderDescBySort is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescBySort() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("sort DESC"))
}

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByUpdatedAt() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("updated_at DESC"))
}

// SortEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortEq(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort = ?", sort))
}

// SortGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortGt(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort > ?", sort))
}

// SortGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortGte(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort >= ?", sort))
}

// SortIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortIn(sort ...uint32) HomeCarouselQuerySet {
	if len(sort) == 0 {
		qs.db.AddError(errors.New("must at least pass one sort in SortIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("sort IN (?)", sort))
}

// SortLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortLt(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort < ?", sort))
}

// SortLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortLte(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort <= ?", sort))
}

// SortNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortNe(sort uint32) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("sort != ?", sort))
}

// SortNotIn is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) SortNotIn(sort ...uint32) HomeCarouselQuerySet {
	if len(sort) == 0 {
		qs.db.AddError(errors.New("must at least pass one sort in SortNotIn"))
		return qs.w(qs.db)
	}
	return qs.w(qs.db.Where("sort NOT IN (?)", sort))
}

// UpdatedAtEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtEq(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

// UpdatedAtGt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtGt(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at > ?", updatedAt))
}

// UpdatedAtGte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtGte(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at >= ?", updatedAt))
}

// UpdatedAtLt is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtLt(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at < ?", updatedAt))
}

// UpdatedAtLte is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtLte(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at <= ?", updatedAt))
}

// UpdatedAtNe is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) UpdatedAtNe(updatedAt time.Time) HomeCarouselQuerySet {
	return qs.w(qs.db.Where("updated_at != ?", updatedAt))
}

// SetCreatedAt is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetCreatedAt(createdAt time.Time) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.CreatedAt)] = createdAt
	return u
}

// SetDeletedAt is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetDeletedAt(deletedAt *time.Time) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.DeletedAt)] = deletedAt
	return u
}

// SetDetail is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetDetail(detail string) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.Detail)] = detail
	return u
}

// SetID is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetID(ID uint32) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.ID)] = ID
	return u
}

// SetImg is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetImg(img string) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.Img)] = img
	return u
}

// SetIsShow is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetIsShow(isShow uint32) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.IsShow)] = isShow
	return u
}

// SetLink is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetLink(link string) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.Link)] = link
	return u
}

// SetName is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetName(name string) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.Name)] = name
	return u
}

// SetSort is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetSort(sort uint32) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.Sort)] = sort
	return u
}

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) SetUpdatedAt(updatedAt time.Time) HomeCarouselUpdater {
	u.fields[string(HomeCarouselDBSchema.UpdatedAt)] = updatedAt
	return u
}

// Update is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) Update() error {
	return u.db.Updates(u.fields).Error
}

// UpdateNum is an autogenerated method
// nolint: dupl
func (u HomeCarouselUpdater) UpdateNum() (int64, error) {
	db := u.db.Updates(u.fields)
	return db.RowsAffected, db.Error
}

// ===== END of query set HomeCarouselQuerySet

// ===== BEGIN of HomeCarousel modifiers

// HomeCarouselDBSchemaField describes database schema field. It requires for method 'Update'
type HomeCarouselDBSchemaField string

// String method returns string representation of field.
// nolint: dupl
func (f HomeCarouselDBSchemaField) String() string {
	return string(f)
}

// HomeCarouselDBSchema stores db field names of HomeCarousel
var HomeCarouselDBSchema = struct {
	ID        HomeCarouselDBSchemaField
	CreatedAt HomeCarouselDBSchemaField
	UpdatedAt HomeCarouselDBSchemaField
	DeletedAt HomeCarouselDBSchemaField
	Name      HomeCarouselDBSchemaField
	Img       HomeCarouselDBSchemaField
	Sort      HomeCarouselDBSchemaField
	IsShow    HomeCarouselDBSchemaField
	Detail    HomeCarouselDBSchemaField
	Link      HomeCarouselDBSchemaField
}{

	ID:        HomeCarouselDBSchemaField("id"),
	CreatedAt: HomeCarouselDBSchemaField("created_at"),
	UpdatedAt: HomeCarouselDBSchemaField("updated_at"),
	DeletedAt: HomeCarouselDBSchemaField("deleted_at"),
	Name:      HomeCarouselDBSchemaField("name"),
	Img:       HomeCarouselDBSchemaField("img"),
	Sort:      HomeCarouselDBSchemaField("sort"),
	IsShow:    HomeCarouselDBSchemaField("is_show"),
	Detail:    HomeCarouselDBSchemaField("detail"),
	Link:      HomeCarouselDBSchemaField("link"),
}

// Update updates HomeCarousel fields by primary key
// nolint: dupl
func (o *HomeCarousel) Update(db *gorm.DB, fields ...HomeCarouselDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":         o.ID,
		"created_at": o.CreatedAt,
		"updated_at": o.UpdatedAt,
		"deleted_at": o.DeletedAt,
		"name":       o.Name,
		"img":        o.Img,
		"sort":       o.Sort,
		"is_show":    o.IsShow,
		"detail":     o.Detail,
		"link":       o.Link,
	}
	u := map[string]interface{}{}
	for _, f := range fields {
		fs := f.String()
		u[fs] = dbNameToFieldName[fs]
	}
	if err := db.Model(o).Updates(u).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return err
		}

		return fmt.Errorf("can't update HomeCarousel %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

// HomeCarouselUpdater is an HomeCarousel updates manager
type HomeCarouselUpdater struct {
	fields map[string]interface{}
	db     *gorm.DB
}

// NewHomeCarouselUpdater creates new HomeCarousel updater
// nolint: dupl
func NewHomeCarouselUpdater(db *gorm.DB) HomeCarouselUpdater {
	return HomeCarouselUpdater{
		fields: map[string]interface{}{},
		db:     db.Model(&HomeCarousel{}),
	}
}

// ===== END of HomeCarousel modifiers

// ===== END of all query sets