mh_server/model/autogenerated_user.go

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

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

	"github.com/jinzhu/gorm"
)

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

// ===== BEGIN of query set CommonProblemQuerySet

// CommonProblemQuerySet is an queryset type for CommonProblem
type CommonProblemQuerySet struct {
	db *gorm.DB
}

// NewCommonProblemQuerySet constructs new CommonProblemQuerySet
func NewCommonProblemQuerySet(db *gorm.DB) CommonProblemQuerySet {
	return CommonProblemQuerySet{
		db: db.Model(&CommonProblem{}),
	}
}

func (qs CommonProblemQuerySet) w(db *gorm.DB) CommonProblemQuerySet {
	return NewCommonProblemQuerySet(db)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) GetUpdater() CommonProblemUpdater {
	return NewCommonProblemUpdater(qs.db)
}

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

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

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

// IDIn is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) IDIn(ID ...uint32) CommonProblemQuerySet {
	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 CommonProblemQuerySet) IDLt(ID uint32) CommonProblemQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

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

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

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) IDNotIn(ID ...uint32) CommonProblemQuerySet {
	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 CommonProblemQuerySet) Limit(limit int) CommonProblemQuerySet {
	return qs.w(qs.db.Limit(limit))
}

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

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

// OrderAscByAnswer is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) OrderAscByAnswer() CommonProblemQuerySet {
	return qs.w(qs.db.Order("answer ASC"))
}

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

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

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

// OrderAscByQuestion is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) OrderAscByQuestion() CommonProblemQuerySet {
	return qs.w(qs.db.Order("question ASC"))
}

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

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

// OrderDescByAnswer is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) OrderDescByAnswer() CommonProblemQuerySet {
	return qs.w(qs.db.Order("answer DESC"))
}

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

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

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

// OrderDescByQuestion is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) OrderDescByQuestion() CommonProblemQuerySet {
	return qs.w(qs.db.Order("question DESC"))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SortIn is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) SortIn(sort ...uint32) CommonProblemQuerySet {
	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 CommonProblemQuerySet) SortLt(sort uint32) CommonProblemQuerySet {
	return qs.w(qs.db.Where("sort < ?", sort))
}

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

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

// SortNotIn is an autogenerated method
// nolint: dupl
func (qs CommonProblemQuerySet) SortNotIn(sort ...uint32) CommonProblemQuerySet {
	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 CommonProblemQuerySet) UpdatedAtEq(updatedAt time.Time) CommonProblemQuerySet {
	return qs.w(qs.db.Where("updated_at = ?", updatedAt))
}

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

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

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

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

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

// SetAnswer is an autogenerated method
// nolint: dupl
func (u CommonProblemUpdater) SetAnswer(answer string) CommonProblemUpdater {
	u.fields[string(CommonProblemDBSchema.Answer)] = answer
	return u
}

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

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

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

// SetQuestion is an autogenerated method
// nolint: dupl
func (u CommonProblemUpdater) SetQuestion(question string) CommonProblemUpdater {
	u.fields[string(CommonProblemDBSchema.Question)] = question
	return u
}

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

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

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

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

// ===== END of query set CommonProblemQuerySet

// ===== BEGIN of CommonProblem modifiers

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

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

// CommonProblemDBSchema stores db field names of CommonProblem
var CommonProblemDBSchema = struct {
	ID        CommonProblemDBSchemaField
	CreatedAt CommonProblemDBSchemaField
	UpdatedAt CommonProblemDBSchemaField
	DeletedAt CommonProblemDBSchemaField
	Question  CommonProblemDBSchemaField
	Answer    CommonProblemDBSchemaField
	Sort      CommonProblemDBSchemaField
}{

	ID:        CommonProblemDBSchemaField("id"),
	CreatedAt: CommonProblemDBSchemaField("created_at"),
	UpdatedAt: CommonProblemDBSchemaField("updated_at"),
	DeletedAt: CommonProblemDBSchemaField("deleted_at"),
	Question:  CommonProblemDBSchemaField("question"),
	Answer:    CommonProblemDBSchemaField("answer"),
	Sort:      CommonProblemDBSchemaField("sort"),
}

// Update updates CommonProblem fields by primary key
// nolint: dupl
func (o *CommonProblem) Update(db *gorm.DB, fields ...CommonProblemDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":         o.ID,
		"created_at": o.CreatedAt,
		"updated_at": o.UpdatedAt,
		"deleted_at": o.DeletedAt,
		"question":   o.Question,
		"answer":     o.Answer,
		"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 CommonProblem %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of CommonProblem modifiers

// ===== BEGIN of query set DepositRefundRecordQuerySet

// DepositRefundRecordQuerySet is an queryset type for DepositRefundRecord
type DepositRefundRecordQuerySet struct {
	db *gorm.DB
}

// NewDepositRefundRecordQuerySet constructs new DepositRefundRecordQuerySet
func NewDepositRefundRecordQuerySet(db *gorm.DB) DepositRefundRecordQuerySet {
	return DepositRefundRecordQuerySet{
		db: db.Model(&DepositRefundRecord{}),
	}
}

func (qs DepositRefundRecordQuerySet) w(db *gorm.DB) DepositRefundRecordQuerySet {
	return NewDepositRefundRecordQuerySet(db)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ConfirmTimeEq is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeEq(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time = ?", confirmTime))
}

// ConfirmTimeGt is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeGt(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time > ?", confirmTime))
}

// ConfirmTimeGte is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeGte(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time >= ?", confirmTime))
}

// ConfirmTimeLt is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeLt(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time < ?", confirmTime))
}

// ConfirmTimeLte is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeLte(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time <= ?", confirmTime))
}

// ConfirmTimeNe is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) ConfirmTimeNe(confirmTime time.Time) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("confirm_time != ?", confirmTime))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) GetUpdater() DepositRefundRecordUpdater {
	return NewDepositRefundRecordUpdater(qs.db)
}

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

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

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

// IDIn is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) IDIn(ID ...uint32) DepositRefundRecordQuerySet {
	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 DepositRefundRecordQuerySet) IDLt(ID uint32) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

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

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

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) IDNotIn(ID ...uint32) DepositRefundRecordQuerySet {
	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 DepositRefundRecordQuerySet) Limit(limit int) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Limit(limit))
}

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

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

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

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

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

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

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

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

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

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

// OrderAscByAmount is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderAscByAmount() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("amount ASC"))
}

// OrderAscByConfirmTime is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderAscByConfirmTime() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("confirm_time ASC"))
}

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

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

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

// OrderAscByOperator is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderAscByOperator() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("operator ASC"))
}

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

// OrderAscByUid is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderAscByUid() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("uid ASC"))
}

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

// OrderDescByAmount is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderDescByAmount() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("amount DESC"))
}

// OrderDescByConfirmTime is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderDescByConfirmTime() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("confirm_time DESC"))
}

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

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

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

// OrderDescByOperator is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderDescByOperator() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("operator DESC"))
}

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

// OrderDescByUid is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) OrderDescByUid() DepositRefundRecordQuerySet {
	return qs.w(qs.db.Order("uid DESC"))
}

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

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

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

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

// StatusIn is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) StatusIn(status ...uint32) DepositRefundRecordQuerySet {
	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 DepositRefundRecordQuerySet) StatusLt(status uint32) DepositRefundRecordQuerySet {
	return qs.w(qs.db.Where("status < ?", status))
}

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

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

// StatusNotIn is an autogenerated method
// nolint: dupl
func (qs DepositRefundRecordQuerySet) StatusNotIn(status ...uint32) DepositRefundRecordQuerySet {
	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))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAmount is an autogenerated method
// nolint: dupl
func (u DepositRefundRecordUpdater) SetAmount(amount uint32) DepositRefundRecordUpdater {
	u.fields[string(DepositRefundRecordDBSchema.Amount)] = amount
	return u
}

// SetConfirmTime is an autogenerated method
// nolint: dupl
func (u DepositRefundRecordUpdater) SetConfirmTime(confirmTime time.Time) DepositRefundRecordUpdater {
	u.fields[string(DepositRefundRecordDBSchema.ConfirmTime)] = confirmTime
	return u
}

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

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

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

// SetOperator is an autogenerated method
// nolint: dupl
func (u DepositRefundRecordUpdater) SetOperator(operator uint32) DepositRefundRecordUpdater {
	u.fields[string(DepositRefundRecordDBSchema.Operator)] = operator
	return u
}

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

// SetUid is an autogenerated method
// nolint: dupl
func (u DepositRefundRecordUpdater) SetUid(uid uint32) DepositRefundRecordUpdater {
	u.fields[string(DepositRefundRecordDBSchema.Uid)] = uid
	return u
}

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

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

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

// ===== END of query set DepositRefundRecordQuerySet

// ===== BEGIN of DepositRefundRecord modifiers

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

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

// DepositRefundRecordDBSchema stores db field names of DepositRefundRecord
var DepositRefundRecordDBSchema = struct {
	ID          DepositRefundRecordDBSchemaField
	CreatedAt   DepositRefundRecordDBSchemaField
	UpdatedAt   DepositRefundRecordDBSchemaField
	DeletedAt   DepositRefundRecordDBSchemaField
	Uid         DepositRefundRecordDBSchemaField
	Status      DepositRefundRecordDBSchemaField
	Amount      DepositRefundRecordDBSchemaField
	Operator    DepositRefundRecordDBSchemaField
	ConfirmTime DepositRefundRecordDBSchemaField
}{

	ID:          DepositRefundRecordDBSchemaField("id"),
	CreatedAt:   DepositRefundRecordDBSchemaField("created_at"),
	UpdatedAt:   DepositRefundRecordDBSchemaField("updated_at"),
	DeletedAt:   DepositRefundRecordDBSchemaField("deleted_at"),
	Uid:         DepositRefundRecordDBSchemaField("uid"),
	Status:      DepositRefundRecordDBSchemaField("status"),
	Amount:      DepositRefundRecordDBSchemaField("amount"),
	Operator:    DepositRefundRecordDBSchemaField("operator"),
	ConfirmTime: DepositRefundRecordDBSchemaField("confirm_time"),
}

// Update updates DepositRefundRecord fields by primary key
// nolint: dupl
func (o *DepositRefundRecord) Update(db *gorm.DB, fields ...DepositRefundRecordDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":           o.ID,
		"created_at":   o.CreatedAt,
		"updated_at":   o.UpdatedAt,
		"deleted_at":   o.DeletedAt,
		"uid":          o.Uid,
		"status":       o.Status,
		"amount":       o.Amount,
		"operator":     o.Operator,
		"confirm_time": o.ConfirmTime,
	}
	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 DepositRefundRecord %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of DepositRefundRecord modifiers

// ===== BEGIN of query set UserInviteQuerySet

// UserInviteQuerySet is an queryset type for UserInvite
type UserInviteQuerySet struct {
	db *gorm.DB
}

// NewUserInviteQuerySet constructs new UserInviteQuerySet
func NewUserInviteQuerySet(db *gorm.DB) UserInviteQuerySet {
	return UserInviteQuerySet{
		db: db.Model(&UserInvite{}),
	}
}

func (qs UserInviteQuerySet) w(db *gorm.DB) UserInviteQuerySet {
	return NewUserInviteQuerySet(db)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// FromUidEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidEq(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid = ?", fromUid))
}

// FromUidGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidGt(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid > ?", fromUid))
}

// FromUidGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidGte(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid >= ?", fromUid))
}

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

// FromUidLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidLt(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid < ?", fromUid))
}

// FromUidLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidLte(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid <= ?", fromUid))
}

// FromUidNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) FromUidNe(fromUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("from_uid != ?", fromUid))
}

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) GetUpdater() UserInviteUpdater {
	return NewUserInviteUpdater(qs.db)
}

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

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

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

// IDIn is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) IDIn(ID ...uint32) UserInviteQuerySet {
	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 UserInviteQuerySet) IDLt(ID uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

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

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

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) IDNotIn(ID ...uint32) UserInviteQuerySet {
	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 UserInviteQuerySet) Limit(limit int) UserInviteQuerySet {
	return qs.w(qs.db.Limit(limit))
}

// MemberOpenTimeEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeEq(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time = ?", memberOpenTime))
}

// MemberOpenTimeGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeGt(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time > ?", memberOpenTime))
}

// MemberOpenTimeGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeGte(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time >= ?", memberOpenTime))
}

// MemberOpenTimeLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeLt(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time < ?", memberOpenTime))
}

// MemberOpenTimeLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeLte(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time <= ?", memberOpenTime))
}

// MemberOpenTimeNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberOpenTimeNe(memberOpenTime time.Time) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_open_time != ?", memberOpenTime))
}

// MemberStatusEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusEq(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status = ?", memberStatus))
}

// MemberStatusGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusGt(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status > ?", memberStatus))
}

// MemberStatusGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusGte(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status >= ?", memberStatus))
}

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

// MemberStatusLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusLt(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status < ?", memberStatus))
}

// MemberStatusLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusLte(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status <= ?", memberStatus))
}

// MemberStatusNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberStatusNe(memberStatus uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_status != ?", memberStatus))
}

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

// MemberTypeEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeEq(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type = ?", memberType))
}

// MemberTypeGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeGt(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type > ?", memberType))
}

// MemberTypeGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeGte(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type >= ?", memberType))
}

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

// MemberTypeLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeLt(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type < ?", memberType))
}

// MemberTypeLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeLte(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type <= ?", memberType))
}

// MemberTypeNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) MemberTypeNe(memberType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("member_type != ?", memberType))
}

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

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

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

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

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

// OrderAscByFromUid is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByFromUid() UserInviteQuerySet {
	return qs.w(qs.db.Order("from_uid ASC"))
}

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

// OrderAscByMemberOpenTime is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByMemberOpenTime() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_open_time ASC"))
}

// OrderAscByMemberStatus is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByMemberStatus() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_status ASC"))
}

// OrderAscByMemberType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByMemberType() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_type ASC"))
}

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

// OrderAscByStoreType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByStoreType() UserInviteQuerySet {
	return qs.w(qs.db.Order("store_type ASC"))
}

// OrderAscByToUid is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByToUid() UserInviteQuerySet {
	return qs.w(qs.db.Order("to_uid ASC"))
}

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

// OrderAscByUserType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderAscByUserType() UserInviteQuerySet {
	return qs.w(qs.db.Order("user_type ASC"))
}

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

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

// OrderDescByFromUid is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByFromUid() UserInviteQuerySet {
	return qs.w(qs.db.Order("from_uid DESC"))
}

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

// OrderDescByMemberOpenTime is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByMemberOpenTime() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_open_time DESC"))
}

// OrderDescByMemberStatus is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByMemberStatus() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_status DESC"))
}

// OrderDescByMemberType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByMemberType() UserInviteQuerySet {
	return qs.w(qs.db.Order("member_type DESC"))
}

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

// OrderDescByStoreType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByStoreType() UserInviteQuerySet {
	return qs.w(qs.db.Order("store_type DESC"))
}

// OrderDescByToUid is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByToUid() UserInviteQuerySet {
	return qs.w(qs.db.Order("to_uid DESC"))
}

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

// OrderDescByUserType is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) OrderDescByUserType() UserInviteQuerySet {
	return qs.w(qs.db.Order("user_type DESC"))
}

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

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

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

// StoreIdIn is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreIdIn(storeId ...uint64) UserInviteQuerySet {
	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 UserInviteQuerySet) StoreIdLt(storeId uint64) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_id < ?", storeId))
}

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

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

// StoreIdNotIn is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreIdNotIn(storeId ...uint64) UserInviteQuerySet {
	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))
}

// StoreTypeEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeEq(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type = ?", storeType))
}

// StoreTypeGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeGt(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type > ?", storeType))
}

// StoreTypeGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeGte(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type >= ?", storeType))
}

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

// StoreTypeLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeLt(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type < ?", storeType))
}

// StoreTypeLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeLte(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type <= ?", storeType))
}

// StoreTypeNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) StoreTypeNe(storeType uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("store_type != ?", storeType))
}

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

// ToUidEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidEq(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid = ?", toUid))
}

// ToUidGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidGt(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid > ?", toUid))
}

// ToUidGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidGte(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid >= ?", toUid))
}

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

// ToUidLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidLt(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid < ?", toUid))
}

// ToUidLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidLte(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid <= ?", toUid))
}

// ToUidNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) ToUidNe(toUid uint32) UserInviteQuerySet {
	return qs.w(qs.db.Where("to_uid != ?", toUid))
}

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

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

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

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

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

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

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

// UserTypeEq is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeEq(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type = ?", userType))
}

// UserTypeGt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeGt(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type > ?", userType))
}

// UserTypeGte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeGte(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type >= ?", userType))
}

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

// UserTypeLt is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeLt(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type < ?", userType))
}

// UserTypeLte is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeLte(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type <= ?", userType))
}

// UserTypeNe is an autogenerated method
// nolint: dupl
func (qs UserInviteQuerySet) UserTypeNe(userType uint8) UserInviteQuerySet {
	return qs.w(qs.db.Where("user_type != ?", userType))
}

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

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

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

// SetFromUid is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetFromUid(fromUid uint32) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.FromUid)] = fromUid
	return u
}

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

// SetMemberOpenTime is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetMemberOpenTime(memberOpenTime time.Time) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.MemberOpenTime)] = memberOpenTime
	return u
}

// SetMemberStatus is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetMemberStatus(memberStatus uint8) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.MemberStatus)] = memberStatus
	return u
}

// SetMemberType is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetMemberType(memberType uint8) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.MemberType)] = memberType
	return u
}

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

// SetStoreType is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetStoreType(storeType uint32) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.StoreType)] = storeType
	return u
}

// SetToUid is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetToUid(toUid uint32) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.ToUid)] = toUid
	return u
}

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

// SetUserType is an autogenerated method
// nolint: dupl
func (u UserInviteUpdater) SetUserType(userType uint8) UserInviteUpdater {
	u.fields[string(UserInviteDBSchema.UserType)] = userType
	return u
}

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

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

// ===== END of query set UserInviteQuerySet

// ===== BEGIN of UserInvite modifiers

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

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

// UserInviteDBSchema stores db field names of UserInvite
var UserInviteDBSchema = struct {
	ID             UserInviteDBSchemaField
	CreatedAt      UserInviteDBSchemaField
	UpdatedAt      UserInviteDBSchemaField
	DeletedAt      UserInviteDBSchemaField
	FromUid        UserInviteDBSchemaField
	UserType       UserInviteDBSchemaField
	StoreId        UserInviteDBSchemaField
	MemberOpenTime UserInviteDBSchemaField
	MemberType     UserInviteDBSchemaField
	MemberStatus   UserInviteDBSchemaField
	ToUid          UserInviteDBSchemaField
	StoreType      UserInviteDBSchemaField
}{

	ID:             UserInviteDBSchemaField("id"),
	CreatedAt:      UserInviteDBSchemaField("created_at"),
	UpdatedAt:      UserInviteDBSchemaField("updated_at"),
	DeletedAt:      UserInviteDBSchemaField("deleted_at"),
	FromUid:        UserInviteDBSchemaField("from_uid"),
	UserType:       UserInviteDBSchemaField("user_type"),
	StoreId:        UserInviteDBSchemaField("store_id"),
	MemberOpenTime: UserInviteDBSchemaField("member_open_time"),
	MemberType:     UserInviteDBSchemaField("member_type"),
	MemberStatus:   UserInviteDBSchemaField("member_status"),
	ToUid:          UserInviteDBSchemaField("to_uid"),
	StoreType:      UserInviteDBSchemaField("store_type"),
}

// Update updates UserInvite fields by primary key
// nolint: dupl
func (o *UserInvite) Update(db *gorm.DB, fields ...UserInviteDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":               o.ID,
		"created_at":       o.CreatedAt,
		"updated_at":       o.UpdatedAt,
		"deleted_at":       o.DeletedAt,
		"from_uid":         o.FromUid,
		"user_type":        o.UserType,
		"store_id":         o.StoreId,
		"member_open_time": o.MemberOpenTime,
		"member_type":      o.MemberType,
		"member_status":    o.MemberStatus,
		"to_uid":           o.ToUid,
		"store_type":       o.StoreType,
	}
	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 UserInvite %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of UserInvite modifiers

// ===== BEGIN of query set UserOpenMemberRecordQuerySet

// UserOpenMemberRecordQuerySet is an queryset type for UserOpenMemberRecord
type UserOpenMemberRecordQuerySet struct {
	db *gorm.DB
}

// NewUserOpenMemberRecordQuerySet constructs new UserOpenMemberRecordQuerySet
func NewUserOpenMemberRecordQuerySet(db *gorm.DB) UserOpenMemberRecordQuerySet {
	return UserOpenMemberRecordQuerySet{
		db: db.Model(&UserOpenMemberRecord{}),
	}
}

func (qs UserOpenMemberRecordQuerySet) w(db *gorm.DB) UserOpenMemberRecordQuerySet {
	return NewUserOpenMemberRecordQuerySet(db)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) GetUpdater() UserOpenMemberRecordUpdater {
	return NewUserOpenMemberRecordUpdater(qs.db)
}

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

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

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

// IDIn is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) IDIn(ID ...uint32) UserOpenMemberRecordQuerySet {
	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 UserOpenMemberRecordQuerySet) IDLt(ID uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

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

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

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) IDNotIn(ID ...uint32) UserOpenMemberRecordQuerySet {
	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 UserOpenMemberRecordQuerySet) Limit(limit int) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Limit(limit))
}

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

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

// OpenNoEq is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoEq(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no = ?", openNo))
}

// OpenNoGt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoGt(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no > ?", openNo))
}

// OpenNoGte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoGte(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no >= ?", openNo))
}

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

// OpenNoLike is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoLike(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no LIKE ?", openNo))
}

// OpenNoLt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoLt(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no < ?", openNo))
}

// OpenNoLte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoLte(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no <= ?", openNo))
}

// OpenNoNe is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoNe(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no != ?", openNo))
}

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

// OpenNoNotlike is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OpenNoNotlike(openNo string) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("open_no NOT LIKE ?", openNo))
}

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

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

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

// OrderAscByOpenNo is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderAscByOpenNo() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("open_no ASC"))
}

// OrderAscByOrderId is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderAscByOrderId() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("order_id ASC"))
}

// OrderAscByOrderType is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderAscByOrderType() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("order_type ASC"))
}

// OrderAscByUid is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderAscByUid() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("uid ASC"))
}

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

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

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

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

// OrderDescByOpenNo is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderDescByOpenNo() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("open_no DESC"))
}

// OrderDescByOrderId is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderDescByOrderId() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("order_id DESC"))
}

// OrderDescByOrderType is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderDescByOrderType() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("order_type DESC"))
}

// OrderDescByUid is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderDescByUid() UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Order("uid DESC"))
}

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

// OrderIdEq is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdEq(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id = ?", orderId))
}

// OrderIdGt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdGt(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id > ?", orderId))
}

// OrderIdGte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdGte(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id >= ?", orderId))
}

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

// OrderIdLt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdLt(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id < ?", orderId))
}

// OrderIdLte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdLte(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id <= ?", orderId))
}

// OrderIdNe is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderIdNe(orderId uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_id != ?", orderId))
}

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

// OrderTypeEq is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeEq(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type = ?", orderType))
}

// OrderTypeGt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeGt(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type > ?", orderType))
}

// OrderTypeGte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeGte(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type >= ?", orderType))
}

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

// OrderTypeLt is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeLt(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type < ?", orderType))
}

// OrderTypeLte is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeLte(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type <= ?", orderType))
}

// OrderTypeNe is an autogenerated method
// nolint: dupl
func (qs UserOpenMemberRecordQuerySet) OrderTypeNe(orderType uint32) UserOpenMemberRecordQuerySet {
	return qs.w(qs.db.Where("order_type != ?", orderType))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetOpenNo is an autogenerated method
// nolint: dupl
func (u UserOpenMemberRecordUpdater) SetOpenNo(openNo string) UserOpenMemberRecordUpdater {
	u.fields[string(UserOpenMemberRecordDBSchema.OpenNo)] = openNo
	return u
}

// SetOrderId is an autogenerated method
// nolint: dupl
func (u UserOpenMemberRecordUpdater) SetOrderId(orderId uint32) UserOpenMemberRecordUpdater {
	u.fields[string(UserOpenMemberRecordDBSchema.OrderId)] = orderId
	return u
}

// SetOrderType is an autogenerated method
// nolint: dupl
func (u UserOpenMemberRecordUpdater) SetOrderType(orderType uint32) UserOpenMemberRecordUpdater {
	u.fields[string(UserOpenMemberRecordDBSchema.OrderType)] = orderType
	return u
}

// SetUid is an autogenerated method
// nolint: dupl
func (u UserOpenMemberRecordUpdater) SetUid(uid uint32) UserOpenMemberRecordUpdater {
	u.fields[string(UserOpenMemberRecordDBSchema.Uid)] = uid
	return u
}

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

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

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

// ===== END of query set UserOpenMemberRecordQuerySet

// ===== BEGIN of UserOpenMemberRecord modifiers

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

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

// UserOpenMemberRecordDBSchema stores db field names of UserOpenMemberRecord
var UserOpenMemberRecordDBSchema = struct {
	ID        UserOpenMemberRecordDBSchemaField
	CreatedAt UserOpenMemberRecordDBSchemaField
	UpdatedAt UserOpenMemberRecordDBSchemaField
	DeletedAt UserOpenMemberRecordDBSchemaField
	Uid       UserOpenMemberRecordDBSchemaField
	OpenNo    UserOpenMemberRecordDBSchemaField
	OrderId   UserOpenMemberRecordDBSchemaField
	OrderType UserOpenMemberRecordDBSchemaField
}{

	ID:        UserOpenMemberRecordDBSchemaField("id"),
	CreatedAt: UserOpenMemberRecordDBSchemaField("created_at"),
	UpdatedAt: UserOpenMemberRecordDBSchemaField("updated_at"),
	DeletedAt: UserOpenMemberRecordDBSchemaField("deleted_at"),
	Uid:       UserOpenMemberRecordDBSchemaField("uid"),
	OpenNo:    UserOpenMemberRecordDBSchemaField("open_no"),
	OrderId:   UserOpenMemberRecordDBSchemaField("order_id"),
	OrderType: UserOpenMemberRecordDBSchemaField("order_type"),
}

// Update updates UserOpenMemberRecord fields by primary key
// nolint: dupl
func (o *UserOpenMemberRecord) Update(db *gorm.DB, fields ...UserOpenMemberRecordDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":         o.ID,
		"created_at": o.CreatedAt,
		"updated_at": o.UpdatedAt,
		"deleted_at": o.DeletedAt,
		"uid":        o.Uid,
		"open_no":    o.OpenNo,
		"order_id":   o.OrderId,
		"order_type": o.OrderType,
	}
	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 UserOpenMemberRecord %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of UserOpenMemberRecord modifiers

// ===== BEGIN of query set UserQuerySet

// UserQuerySet is an queryset type for User
type UserQuerySet struct {
	db *gorm.DB
}

// NewUserQuerySet constructs new UserQuerySet
func NewUserQuerySet(db *gorm.DB) UserQuerySet {
	return UserQuerySet{
		db: db.Model(&User{}),
	}
}

func (qs UserQuerySet) w(db *gorm.DB) UserQuerySet {
	return NewUserQuerySet(db)
}

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

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

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

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

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

// AppOpenIDEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDEq(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id = ?", appOpenID))
}

// AppOpenIDGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDGt(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id > ?", appOpenID))
}

// AppOpenIDGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDGte(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id >= ?", appOpenID))
}

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

// AppOpenIDLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDLike(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id LIKE ?", appOpenID))
}

// AppOpenIDLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDLt(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id < ?", appOpenID))
}

// AppOpenIDLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDLte(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id <= ?", appOpenID))
}

// AppOpenIDNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDNe(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id != ?", appOpenID))
}

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

// AppOpenIDNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) AppOpenIDNotlike(appOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("app_open_id NOT LIKE ?", appOpenID))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) GetUpdater() UserUpdater {
	return NewUserUpdater(qs.db)
}

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

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

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

// IDIn is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IDIn(ID ...uint32) UserQuerySet {
	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 UserQuerySet) IDLt(ID uint32) UserQuerySet {
	return qs.w(qs.db.Where("id < ?", ID))
}

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

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

// IDNotIn is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IDNotIn(ID ...uint32) UserQuerySet {
	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))
}

// IPEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPEq(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip = ?", IP))
}

// IPGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPGt(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip > ?", IP))
}

// IPGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPGte(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip >= ?", IP))
}

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

// IPLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPLike(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip LIKE ?", IP))
}

// IPLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPLt(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip < ?", IP))
}

// IPLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPLte(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip <= ?", IP))
}

// IPNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPNe(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip != ?", IP))
}

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

// IPNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) IPNotlike(IP string) UserQuerySet {
	return qs.w(qs.db.Where("ip NOT LIKE ?", IP))
}

// InBlackEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InBlackEq(inBlack bool) UserQuerySet {
	return qs.w(qs.db.Where("in_black = ?", inBlack))
}

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

// InBlackNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InBlackNe(inBlack bool) UserQuerySet {
	return qs.w(qs.db.Where("in_black != ?", inBlack))
}

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

// InviteCodeUrlEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlEq(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url = ?", inviteCodeUrl))
}

// InviteCodeUrlGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlGt(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url > ?", inviteCodeUrl))
}

// InviteCodeUrlGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlGte(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url >= ?", inviteCodeUrl))
}

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

// InviteCodeUrlLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlLike(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url LIKE ?", inviteCodeUrl))
}

// InviteCodeUrlLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlLt(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url < ?", inviteCodeUrl))
}

// InviteCodeUrlLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlLte(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url <= ?", inviteCodeUrl))
}

// InviteCodeUrlNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlNe(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url != ?", inviteCodeUrl))
}

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

// InviteCodeUrlNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) InviteCodeUrlNotlike(inviteCodeUrl string) UserQuerySet {
	return qs.w(qs.db.Where("invite_code_url NOT LIKE ?", inviteCodeUrl))
}

// LastLoginAtEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtEq(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at = ?", lastLoginAt))
}

// LastLoginAtGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtGt(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at > ?", lastLoginAt))
}

// LastLoginAtGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtGte(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at >= ?", lastLoginAt))
}

// LastLoginAtLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtLt(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at < ?", lastLoginAt))
}

// LastLoginAtLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtLte(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at <= ?", lastLoginAt))
}

// LastLoginAtNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) LastLoginAtNe(lastLoginAt time.Time) UserQuerySet {
	return qs.w(qs.db.Where("last_login_at != ?", lastLoginAt))
}

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

// MemberExpireEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireEq(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire = ?", memberExpire))
}

// MemberExpireGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireGt(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire > ?", memberExpire))
}

// MemberExpireGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireGte(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire >= ?", memberExpire))
}

// MemberExpireLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireLt(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire < ?", memberExpire))
}

// MemberExpireLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireLte(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire <= ?", memberExpire))
}

// MemberExpireNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberExpireNe(memberExpire time.Time) UserQuerySet {
	return qs.w(qs.db.Where("member_expire != ?", memberExpire))
}

// MemberLevelEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelEq(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level = ?", memberLevel))
}

// MemberLevelGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelGt(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level > ?", memberLevel))
}

// MemberLevelGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelGte(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level >= ?", memberLevel))
}

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

// MemberLevelLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelLt(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level < ?", memberLevel))
}

// MemberLevelLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelLte(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level <= ?", memberLevel))
}

// MemberLevelNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) MemberLevelNe(memberLevel uint32) UserQuerySet {
	return qs.w(qs.db.Where("member_level != ?", memberLevel))
}

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

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

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

// OrderAscByAppOpenID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByAppOpenID() UserQuerySet {
	return qs.w(qs.db.Order("app_open_id ASC"))
}

// OrderAscByBond is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByBond() UserQuerySet {
	return qs.w(qs.db.Order("bond ASC"))
}

// OrderAscByCity is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByCity() UserQuerySet {
	return qs.w(qs.db.Order("city ASC"))
}

// OrderAscByCountry is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByCountry() UserQuerySet {
	return qs.w(qs.db.Order("country ASC"))
}

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

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

// OrderAscByDeposit is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByDeposit() UserQuerySet {
	return qs.w(qs.db.Order("deposit ASC"))
}

// OrderAscByGender is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByGender() UserQuerySet {
	return qs.w(qs.db.Order("gender ASC"))
}

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

// OrderAscByIP is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByIP() UserQuerySet {
	return qs.w(qs.db.Order("ip ASC"))
}

// OrderAscByInBlack is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByInBlack() UserQuerySet {
	return qs.w(qs.db.Order("in_black ASC"))
}

// OrderAscByInviteCodeUrl is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByInviteCodeUrl() UserQuerySet {
	return qs.w(qs.db.Order("invite_code_url ASC"))
}

// OrderAscByLastLoginAt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByLastLoginAt() UserQuerySet {
	return qs.w(qs.db.Order("last_login_at ASC"))
}

// OrderAscByMemberExpire is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByMemberExpire() UserQuerySet {
	return qs.w(qs.db.Order("member_expire ASC"))
}

// OrderAscByMemberLevel is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByMemberLevel() UserQuerySet {
	return qs.w(qs.db.Order("member_level ASC"))
}

// OrderAscByProvince is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByProvince() UserQuerySet {
	return qs.w(qs.db.Order("province ASC"))
}

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

// OrderAscByStoreType is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByStoreType() UserQuerySet {
	return qs.w(qs.db.Order("store_type ASC"))
}

// OrderAscByTel is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByTel() UserQuerySet {
	return qs.w(qs.db.Order("tel ASC"))
}

// OrderAscByUid is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByUid() UserQuerySet {
	return qs.w(qs.db.Order("uid ASC"))
}

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

// OrderAscByUserType is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByUserType() UserQuerySet {
	return qs.w(qs.db.Order("user_type ASC"))
}

// OrderAscByVersion is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByVersion() UserQuerySet {
	return qs.w(qs.db.Order("version ASC"))
}

// OrderAscByWxAvatar is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByWxAvatar() UserQuerySet {
	return qs.w(qs.db.Order("wx_avatar ASC"))
}

// OrderAscByWxName is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByWxName() UserQuerySet {
	return qs.w(qs.db.Order("wx_name ASC"))
}

// OrderAscByWxOpenID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByWxOpenID() UserQuerySet {
	return qs.w(qs.db.Order("wx_open_id ASC"))
}

// OrderAscByWxUnionID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderAscByWxUnionID() UserQuerySet {
	return qs.w(qs.db.Order("wx_union_id ASC"))
}

// OrderDescByAppOpenID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByAppOpenID() UserQuerySet {
	return qs.w(qs.db.Order("app_open_id DESC"))
}

// OrderDescByBond is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByBond() UserQuerySet {
	return qs.w(qs.db.Order("bond DESC"))
}

// OrderDescByCity is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByCity() UserQuerySet {
	return qs.w(qs.db.Order("city DESC"))
}

// OrderDescByCountry is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByCountry() UserQuerySet {
	return qs.w(qs.db.Order("country DESC"))
}

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

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

// OrderDescByDeposit is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByDeposit() UserQuerySet {
	return qs.w(qs.db.Order("deposit DESC"))
}

// OrderDescByGender is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByGender() UserQuerySet {
	return qs.w(qs.db.Order("gender DESC"))
}

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

// OrderDescByIP is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByIP() UserQuerySet {
	return qs.w(qs.db.Order("ip DESC"))
}

// OrderDescByInBlack is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByInBlack() UserQuerySet {
	return qs.w(qs.db.Order("in_black DESC"))
}

// OrderDescByInviteCodeUrl is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByInviteCodeUrl() UserQuerySet {
	return qs.w(qs.db.Order("invite_code_url DESC"))
}

// OrderDescByLastLoginAt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByLastLoginAt() UserQuerySet {
	return qs.w(qs.db.Order("last_login_at DESC"))
}

// OrderDescByMemberExpire is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByMemberExpire() UserQuerySet {
	return qs.w(qs.db.Order("member_expire DESC"))
}

// OrderDescByMemberLevel is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByMemberLevel() UserQuerySet {
	return qs.w(qs.db.Order("member_level DESC"))
}

// OrderDescByProvince is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByProvince() UserQuerySet {
	return qs.w(qs.db.Order("province DESC"))
}

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

// OrderDescByStoreType is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByStoreType() UserQuerySet {
	return qs.w(qs.db.Order("store_type DESC"))
}

// OrderDescByTel is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByTel() UserQuerySet {
	return qs.w(qs.db.Order("tel DESC"))
}

// OrderDescByUid is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByUid() UserQuerySet {
	return qs.w(qs.db.Order("uid DESC"))
}

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

// OrderDescByUserType is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByUserType() UserQuerySet {
	return qs.w(qs.db.Order("user_type DESC"))
}

// OrderDescByVersion is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByVersion() UserQuerySet {
	return qs.w(qs.db.Order("version DESC"))
}

// OrderDescByWxAvatar is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByWxAvatar() UserQuerySet {
	return qs.w(qs.db.Order("wx_avatar DESC"))
}

// OrderDescByWxName is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByWxName() UserQuerySet {
	return qs.w(qs.db.Order("wx_name DESC"))
}

// OrderDescByWxOpenID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByWxOpenID() UserQuerySet {
	return qs.w(qs.db.Order("wx_open_id DESC"))
}

// OrderDescByWxUnionID is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) OrderDescByWxUnionID() UserQuerySet {
	return qs.w(qs.db.Order("wx_union_id DESC"))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// StoreIdIn is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreIdIn(storeId ...uint64) UserQuerySet {
	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 UserQuerySet) StoreIdLt(storeId uint64) UserQuerySet {
	return qs.w(qs.db.Where("store_id < ?", storeId))
}

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

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

// StoreIdNotIn is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreIdNotIn(storeId ...uint64) UserQuerySet {
	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))
}

// StoreTypeEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeEq(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type = ?", storeType))
}

// StoreTypeGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeGt(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type > ?", storeType))
}

// StoreTypeGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeGte(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type >= ?", storeType))
}

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

// StoreTypeLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeLt(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type < ?", storeType))
}

// StoreTypeLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeLte(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type <= ?", storeType))
}

// StoreTypeNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) StoreTypeNe(storeType uint8) UserQuerySet {
	return qs.w(qs.db.Where("store_type != ?", storeType))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UserTypeEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeEq(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type = ?", userType))
}

// UserTypeGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeGt(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type > ?", userType))
}

// UserTypeGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeGte(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type >= ?", userType))
}

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

// UserTypeLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeLt(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type < ?", userType))
}

// UserTypeLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeLte(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type <= ?", userType))
}

// UserTypeNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) UserTypeNe(userType uint8) UserQuerySet {
	return qs.w(qs.db.Where("user_type != ?", userType))
}

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

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

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

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

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

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

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

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

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

// WxAvatarEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarEq(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar = ?", wxAvatar))
}

// WxAvatarGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarGt(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar > ?", wxAvatar))
}

// WxAvatarGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarGte(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar >= ?", wxAvatar))
}

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

// WxAvatarLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarLike(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar LIKE ?", wxAvatar))
}

// WxAvatarLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarLt(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar < ?", wxAvatar))
}

// WxAvatarLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarLte(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar <= ?", wxAvatar))
}

// WxAvatarNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarNe(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar != ?", wxAvatar))
}

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

// WxAvatarNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxAvatarNotlike(wxAvatar string) UserQuerySet {
	return qs.w(qs.db.Where("wx_avatar NOT LIKE ?", wxAvatar))
}

// WxNameEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameEq(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name = ?", wxName))
}

// WxNameGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameGt(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name > ?", wxName))
}

// WxNameGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameGte(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name >= ?", wxName))
}

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

// WxNameLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameLike(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name LIKE ?", wxName))
}

// WxNameLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameLt(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name < ?", wxName))
}

// WxNameLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameLte(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name <= ?", wxName))
}

// WxNameNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameNe(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name != ?", wxName))
}

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

// WxNameNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxNameNotlike(wxName string) UserQuerySet {
	return qs.w(qs.db.Where("wx_name NOT LIKE ?", wxName))
}

// WxOpenIDEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDEq(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id = ?", wxOpenID))
}

// WxOpenIDGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDGt(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id > ?", wxOpenID))
}

// WxOpenIDGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDGte(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id >= ?", wxOpenID))
}

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

// WxOpenIDLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDLike(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id LIKE ?", wxOpenID))
}

// WxOpenIDLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDLt(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id < ?", wxOpenID))
}

// WxOpenIDLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDLte(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id <= ?", wxOpenID))
}

// WxOpenIDNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDNe(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id != ?", wxOpenID))
}

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

// WxOpenIDNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxOpenIDNotlike(wxOpenID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_open_id NOT LIKE ?", wxOpenID))
}

// WxUnionIDEq is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDEq(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id = ?", wxUnionID))
}

// WxUnionIDGt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDGt(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id > ?", wxUnionID))
}

// WxUnionIDGte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDGte(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id >= ?", wxUnionID))
}

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

// WxUnionIDLike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDLike(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id LIKE ?", wxUnionID))
}

// WxUnionIDLt is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDLt(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id < ?", wxUnionID))
}

// WxUnionIDLte is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDLte(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id <= ?", wxUnionID))
}

// WxUnionIDNe is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDNe(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id != ?", wxUnionID))
}

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

// WxUnionIDNotlike is an autogenerated method
// nolint: dupl
func (qs UserQuerySet) WxUnionIDNotlike(wxUnionID string) UserQuerySet {
	return qs.w(qs.db.Where("wx_union_id NOT LIKE ?", wxUnionID))
}

// SetAppOpenID is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetAppOpenID(appOpenID string) UserUpdater {
	u.fields[string(UserDBSchema.AppOpenID)] = appOpenID
	return u
}

// SetBond is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetBond(bond uint32) UserUpdater {
	u.fields[string(UserDBSchema.Bond)] = bond
	return u
}

// SetCity is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetCity(city string) UserUpdater {
	u.fields[string(UserDBSchema.City)] = city
	return u
}

// SetCountry is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetCountry(country string) UserUpdater {
	u.fields[string(UserDBSchema.Country)] = country
	return u
}

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

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

// SetDeposit is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetDeposit(deposit uint32) UserUpdater {
	u.fields[string(UserDBSchema.Deposit)] = deposit
	return u
}

// SetGender is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetGender(gender uint8) UserUpdater {
	u.fields[string(UserDBSchema.Gender)] = gender
	return u
}

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

// SetIP is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetIP(IP string) UserUpdater {
	u.fields[string(UserDBSchema.IP)] = IP
	return u
}

// SetInBlack is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetInBlack(inBlack bool) UserUpdater {
	u.fields[string(UserDBSchema.InBlack)] = inBlack
	return u
}

// SetInviteCodeUrl is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetInviteCodeUrl(inviteCodeUrl string) UserUpdater {
	u.fields[string(UserDBSchema.InviteCodeUrl)] = inviteCodeUrl
	return u
}

// SetLastLoginAt is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetLastLoginAt(lastLoginAt time.Time) UserUpdater {
	u.fields[string(UserDBSchema.LastLoginAt)] = lastLoginAt
	return u
}

// SetMemberExpire is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetMemberExpire(memberExpire time.Time) UserUpdater {
	u.fields[string(UserDBSchema.MemberExpire)] = memberExpire
	return u
}

// SetMemberLevel is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetMemberLevel(memberLevel uint32) UserUpdater {
	u.fields[string(UserDBSchema.MemberLevel)] = memberLevel
	return u
}

// SetProvince is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetProvince(province string) UserUpdater {
	u.fields[string(UserDBSchema.Province)] = province
	return u
}

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

// SetStoreType is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetStoreType(storeType uint8) UserUpdater {
	u.fields[string(UserDBSchema.StoreType)] = storeType
	return u
}

// SetTel is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetTel(tel string) UserUpdater {
	u.fields[string(UserDBSchema.Tel)] = tel
	return u
}

// SetUid is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetUid(uid uint32) UserUpdater {
	u.fields[string(UserDBSchema.Uid)] = uid
	return u
}

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

// SetUserType is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetUserType(userType uint8) UserUpdater {
	u.fields[string(UserDBSchema.UserType)] = userType
	return u
}

// SetVersion is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetVersion(version uint32) UserUpdater {
	u.fields[string(UserDBSchema.Version)] = version
	return u
}

// SetWxAvatar is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetWxAvatar(wxAvatar string) UserUpdater {
	u.fields[string(UserDBSchema.WxAvatar)] = wxAvatar
	return u
}

// SetWxName is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetWxName(wxName string) UserUpdater {
	u.fields[string(UserDBSchema.WxName)] = wxName
	return u
}

// SetWxOpenID is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetWxOpenID(wxOpenID string) UserUpdater {
	u.fields[string(UserDBSchema.WxOpenID)] = wxOpenID
	return u
}

// SetWxUnionID is an autogenerated method
// nolint: dupl
func (u UserUpdater) SetWxUnionID(wxUnionID string) UserUpdater {
	u.fields[string(UserDBSchema.WxUnionID)] = wxUnionID
	return u
}

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

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

// ===== END of query set UserQuerySet

// ===== BEGIN of User modifiers

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

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

// UserDBSchema stores db field names of User
var UserDBSchema = struct {
	ID            UserDBSchemaField
	CreatedAt     UserDBSchemaField
	UpdatedAt     UserDBSchemaField
	DeletedAt     UserDBSchemaField
	Uid           UserDBSchemaField
	MemberLevel   UserDBSchemaField
	MemberExpire  UserDBSchemaField
	Bond          UserDBSchemaField
	WxName        UserDBSchemaField
	WxAvatar      UserDBSchemaField
	WxOpenID      UserDBSchemaField
	AppOpenID     UserDBSchemaField
	WxUnionID     UserDBSchemaField
	Tel           UserDBSchemaField
	Gender        UserDBSchemaField
	City          UserDBSchemaField
	Province      UserDBSchemaField
	Country       UserDBSchemaField
	Deposit       UserDBSchemaField
	UserType      UserDBSchemaField
	StoreId       UserDBSchemaField
	InviteCodeUrl UserDBSchemaField
	LastLoginAt   UserDBSchemaField
	IP            UserDBSchemaField
	InBlack       UserDBSchemaField
	StoreType     UserDBSchemaField
	Version       UserDBSchemaField
}{

	ID:            UserDBSchemaField("id"),
	CreatedAt:     UserDBSchemaField("created_at"),
	UpdatedAt:     UserDBSchemaField("updated_at"),
	DeletedAt:     UserDBSchemaField("deleted_at"),
	Uid:           UserDBSchemaField("uid"),
	MemberLevel:   UserDBSchemaField("member_level"),
	MemberExpire:  UserDBSchemaField("member_expire"),
	Bond:          UserDBSchemaField("bond"),
	WxName:        UserDBSchemaField("wx_name"),
	WxAvatar:      UserDBSchemaField("wx_avatar"),
	WxOpenID:      UserDBSchemaField("wx_open_id"),
	AppOpenID:     UserDBSchemaField("app_open_id"),
	WxUnionID:     UserDBSchemaField("wx_union_id"),
	Tel:           UserDBSchemaField("tel"),
	Gender:        UserDBSchemaField("gender"),
	City:          UserDBSchemaField("city"),
	Province:      UserDBSchemaField("province"),
	Country:       UserDBSchemaField("country"),
	Deposit:       UserDBSchemaField("deposit"),
	UserType:      UserDBSchemaField("user_type"),
	StoreId:       UserDBSchemaField("store_id"),
	InviteCodeUrl: UserDBSchemaField("invite_code_url"),
	LastLoginAt:   UserDBSchemaField("last_login_at"),
	IP:            UserDBSchemaField("ip"),
	InBlack:       UserDBSchemaField("in_black"),
	StoreType:     UserDBSchemaField("store_type"),
	Version:       UserDBSchemaField("version"),
}

// Update updates User fields by primary key
// nolint: dupl
func (o *User) Update(db *gorm.DB, fields ...UserDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":              o.ID,
		"created_at":      o.CreatedAt,
		"updated_at":      o.UpdatedAt,
		"deleted_at":      o.DeletedAt,
		"uid":             o.Uid,
		"member_level":    o.MemberLevel,
		"member_expire":   o.MemberExpire,
		"bond":            o.Bond,
		"wx_name":         o.WxName,
		"wx_avatar":       o.WxAvatar,
		"wx_open_id":      o.WxOpenID,
		"app_open_id":     o.AppOpenID,
		"wx_union_id":     o.WxUnionID,
		"tel":             o.Tel,
		"gender":          o.Gender,
		"city":            o.City,
		"province":        o.Province,
		"country":         o.Country,
		"deposit":         o.Deposit,
		"user_type":       o.UserType,
		"store_id":        o.StoreId,
		"invite_code_url": o.InviteCodeUrl,
		"last_login_at":   o.LastLoginAt,
		"ip":              o.IP,
		"in_black":        o.InBlack,
		"store_type":      o.StoreType,
		"version":         o.Version,
	}
	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 User %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of User modifiers

// ===== END of all query sets