mh_server/model/autogenerated_game_card.go

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

import (
	"errors"
	"fmt"
	"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)
}

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

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

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

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

// OrderAscByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderAscByID() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("id 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"))
}

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

// OrderDescByID is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) OrderDescByID() GameCardGoodsQuerySet {
	return qs.w(qs.db.Order("id 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"))
}

// SerialNumberEq is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsQuerySet) SerialNumberEq(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))
}

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

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

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

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

// SetSerialNumber is an autogenerated method
// nolint: dupl
func (u GameCardGoodsUpdater) SetSerialNumber(serialNumber string) GameCardGoodsUpdater {
	u.fields[string(GameCardGoodsDBSchema.SerialNumber)] = serialNumber
	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
	SerialNumber GameCardGoodsDBSchemaField
	Status       GameCardGoodsDBSchemaField
	StoreId      GameCardGoodsDBSchemaField
}{

	ID:           GameCardGoodsDBSchemaField("id"),
	CreatedAt:    GameCardGoodsDBSchemaField("created_at"),
	UpdatedAt:    GameCardGoodsDBSchemaField("updated_at"),
	DeletedAt:    GameCardGoodsDBSchemaField("deleted_at"),
	SerialNumber: GameCardGoodsDBSchemaField("serial_number"),
	Status:       GameCardGoodsDBSchemaField("status"),
	StoreId:      GameCardGoodsDBSchemaField("store_id"),
}

// 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,
		"serial_number": o.SerialNumber,
		"status":        o.Status,
		"store_id":      o.StoreId,
	}
	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)
}

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

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

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

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

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

// OrderDescByUpdatedAt is an autogenerated method
// nolint: dupl
func (qs GameCardGoodsStockQuerySet) OrderDescByUpdatedAt() GameCardGoodsStockQuerySet {
	return qs.w(qs.db.Order("updated_at 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))
}

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

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

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

// SetUpdatedAt is an autogenerated method
// nolint: dupl
func (u GameCardGoodsStockUpdater) SetUpdatedAt(updatedAt time.Time) GameCardGoodsStockUpdater {
	u.fields[string(GameCardGoodsStockDBSchema.UpdatedAt)] = updatedAt
	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
}{

	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"),
}

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

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

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

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

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

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

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

// DetailInfoEq is an autogenerated method
// nolint: dupl
func (qs GameCardQuerySet) DetailInfoEq(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))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NameEq is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) NameEq(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))
}

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

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

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

// OrderAscByIsShow is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderAscByIsShow() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("is_show 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"))
}

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

// OrderDescByIsShow is an autogenerated method
// nolint: dupl
func (qs HomeCarouselQuerySet) OrderDescByIsShow() HomeCarouselQuerySet {
	return qs.w(qs.db.Order("is_show 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