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

// ActivityMemberRenewalQuerySet is an queryset type for ActivityMemberRenewal
type ActivityMemberRenewalQuerySet struct {
	db *gorm.DB
}

// NewActivityMemberRenewalQuerySet constructs new ActivityMemberRenewalQuerySet
func NewActivityMemberRenewalQuerySet(db *gorm.DB) ActivityMemberRenewalQuerySet {
	return ActivityMemberRenewalQuerySet{
		db: db.Model(&ActivityMemberRenewal{}),
	}
}

func (qs ActivityMemberRenewalQuerySet) w(db *gorm.DB) ActivityMemberRenewalQuerySet {
	return NewActivityMemberRenewalQuerySet(db)
}

func (qs ActivityMemberRenewalQuerySet) Select(fields ...ActivityMemberRenewalDBSchemaField) ActivityMemberRenewalQuerySet {
	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 *ActivityMemberRenewal) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

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

// ActivityIdEq is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdEq(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id = ?", activityId))
}

// ActivityIdGt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdGt(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id > ?", activityId))
}

// ActivityIdGte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdGte(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id >= ?", activityId))
}

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

// ActivityIdLt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdLt(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id < ?", activityId))
}

// ActivityIdLte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdLte(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id <= ?", activityId))
}

// ActivityIdNe is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) ActivityIdNe(activityId uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("activity_id != ?", activityId))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) GetUpdater() ActivityMemberRenewalUpdater {
	return NewActivityMemberRenewalUpdater(qs.db)
}

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

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

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

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

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

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

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

// IsPopEq is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) IsPopEq(isPop bool) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("is_pop = ?", isPop))
}

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

// IsPopNe is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) IsPopNe(isPop bool) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("is_pop != ?", isPop))
}

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

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

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

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

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

// MemberLevelIn is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberLevelIn(memberLevel ...uint32) ActivityMemberRenewalQuerySet {
	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 ActivityMemberRenewalQuerySet) MemberLevelLt(memberLevel uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_level < ?", memberLevel))
}

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

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

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

// MemberSerialEq is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialEq(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial = ?", memberSerial))
}

// MemberSerialGt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialGt(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial > ?", memberSerial))
}

// MemberSerialGte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialGte(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial >= ?", memberSerial))
}

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

// MemberSerialLt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialLt(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial < ?", memberSerial))
}

// MemberSerialLte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialLte(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial <= ?", memberSerial))
}

// MemberSerialNe is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) MemberSerialNe(memberSerial uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("member_serial != ?", memberSerial))
}

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

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

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

// OrderAscByActivityId is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderAscByActivityId() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("activity_id ASC"))
}

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

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

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

// OrderAscByIsPop is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderAscByIsPop() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("is_pop ASC"))
}

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

// OrderAscByMemberSerial is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderAscByMemberSerial() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("member_serial ASC"))
}

// OrderAscByStartTime is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderAscByStartTime() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("start_time ASC"))
}

// OrderAscByState is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderAscByState() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("state ASC"))
}

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

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

// OrderDescByActivityId is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderDescByActivityId() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("activity_id DESC"))
}

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

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

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

// OrderDescByIsPop is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderDescByIsPop() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("is_pop DESC"))
}

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

// OrderDescByMemberSerial is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderDescByMemberSerial() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("member_serial DESC"))
}

// OrderDescByStartTime is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderDescByStartTime() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("start_time DESC"))
}

// OrderDescByState is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) OrderDescByState() ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Order("state DESC"))
}

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

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

// StartTimeEq is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeEq(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time = ?", startTime))
}

// StartTimeGt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeGt(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time > ?", startTime))
}

// StartTimeGte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeGte(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time >= ?", startTime))
}

// StartTimeLt is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeLt(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time < ?", startTime))
}

// StartTimeLte is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeLte(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time <= ?", startTime))
}

// StartTimeNe is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) StartTimeNe(startTime time.Time) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("start_time != ?", startTime))
}

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

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

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

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

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

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

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

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

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

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

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

// UidIn is an autogenerated method
// nolint: dupl
func (qs ActivityMemberRenewalQuerySet) UidIn(uid ...uint32) ActivityMemberRenewalQuerySet {
	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 ActivityMemberRenewalQuerySet) UidLt(uid uint32) ActivityMemberRenewalQuerySet {
	return qs.w(qs.db.Where("uid < ?", uid))
}

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

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

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

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

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

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

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

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

// SetActivityId is an autogenerated method
// nolint: dupl
func (u ActivityMemberRenewalUpdater) SetActivityId(activityId uint32) ActivityMemberRenewalUpdater {
	u.fields[string(ActivityMemberRenewalDBSchema.ActivityId)] = activityId
	return u
}

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

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

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

// SetIsPop is an autogenerated method
// nolint: dupl
func (u ActivityMemberRenewalUpdater) SetIsPop(isPop bool) ActivityMemberRenewalUpdater {
	u.fields[string(ActivityMemberRenewalDBSchema.IsPop)] = isPop
	return u
}

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

// SetMemberSerial is an autogenerated method
// nolint: dupl
func (u ActivityMemberRenewalUpdater) SetMemberSerial(memberSerial uint32) ActivityMemberRenewalUpdater {
	u.fields[string(ActivityMemberRenewalDBSchema.MemberSerial)] = memberSerial
	return u
}

// SetStartTime is an autogenerated method
// nolint: dupl
func (u ActivityMemberRenewalUpdater) SetStartTime(startTime time.Time) ActivityMemberRenewalUpdater {
	u.fields[string(ActivityMemberRenewalDBSchema.StartTime)] = startTime
	return u
}

// SetState is an autogenerated method
// nolint: dupl
func (u ActivityMemberRenewalUpdater) SetState(state uint32) ActivityMemberRenewalUpdater {
	u.fields[string(ActivityMemberRenewalDBSchema.State)] = state
	return u
}

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

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

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

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

// ===== END of query set ActivityMemberRenewalQuerySet

// ===== BEGIN of ActivityMemberRenewal modifiers

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

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

// ActivityMemberRenewalDBSchema stores db field names of ActivityMemberRenewal
var ActivityMemberRenewalDBSchema = struct {
	ID           ActivityMemberRenewalDBSchemaField
	CreatedAt    ActivityMemberRenewalDBSchemaField
	UpdatedAt    ActivityMemberRenewalDBSchemaField
	DeletedAt    ActivityMemberRenewalDBSchemaField
	ActivityId   ActivityMemberRenewalDBSchemaField
	Uid          ActivityMemberRenewalDBSchemaField
	State        ActivityMemberRenewalDBSchemaField
	StartTime    ActivityMemberRenewalDBSchemaField
	IsPop        ActivityMemberRenewalDBSchemaField
	MemberLevel  ActivityMemberRenewalDBSchemaField
	MemberSerial ActivityMemberRenewalDBSchemaField
}{

	ID:           ActivityMemberRenewalDBSchemaField("id"),
	CreatedAt:    ActivityMemberRenewalDBSchemaField("created_at"),
	UpdatedAt:    ActivityMemberRenewalDBSchemaField("updated_at"),
	DeletedAt:    ActivityMemberRenewalDBSchemaField("deleted_at"),
	ActivityId:   ActivityMemberRenewalDBSchemaField("activity_id"),
	Uid:          ActivityMemberRenewalDBSchemaField("uid"),
	State:        ActivityMemberRenewalDBSchemaField("state"),
	StartTime:    ActivityMemberRenewalDBSchemaField("start_time"),
	IsPop:        ActivityMemberRenewalDBSchemaField("is_pop"),
	MemberLevel:  ActivityMemberRenewalDBSchemaField("member_level"),
	MemberSerial: ActivityMemberRenewalDBSchemaField("member_serial"),
}

// Update updates ActivityMemberRenewal fields by primary key
// nolint: dupl
func (o *ActivityMemberRenewal) Update(db *gorm.DB, fields ...ActivityMemberRenewalDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":            o.ID,
		"created_at":    o.CreatedAt,
		"updated_at":    o.UpdatedAt,
		"deleted_at":    o.DeletedAt,
		"activity_id":   o.ActivityId,
		"uid":           o.Uid,
		"state":         o.State,
		"start_time":    o.StartTime,
		"is_pop":        o.IsPop,
		"member_level":  o.MemberLevel,
		"member_serial": o.MemberSerial,
	}
	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 ActivityMemberRenewal %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of ActivityMemberRenewal modifiers

// ===== BEGIN of query set ActivityQuerySet

// ActivityQuerySet is an queryset type for Activity
type ActivityQuerySet struct {
	db *gorm.DB
}

// NewActivityQuerySet constructs new ActivityQuerySet
func NewActivityQuerySet(db *gorm.DB) ActivityQuerySet {
	return ActivityQuerySet{
		db: db.Model(&Activity{}),
	}
}

func (qs ActivityQuerySet) w(db *gorm.DB) ActivityQuerySet {
	return NewActivityQuerySet(db)
}

func (qs ActivityQuerySet) Select(fields ...ActivityDBSchemaField) ActivityQuerySet {
	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 *Activity) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

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

// ActivityTypeEq is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeEq(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type = ?", activityType))
}

// ActivityTypeGt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeGt(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type > ?", activityType))
}

// ActivityTypeGte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeGte(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type >= ?", activityType))
}

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

// ActivityTypeLt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeLt(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type < ?", activityType))
}

// ActivityTypeLte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeLte(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type <= ?", activityType))
}

// ActivityTypeNe is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) ActivityTypeNe(activityType uint32) ActivityQuerySet {
	return qs.w(qs.db.Where("activity_type != ?", activityType))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// EndTimeEq is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeEq(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time = ?", endTime))
}

// EndTimeGt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeGt(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time > ?", endTime))
}

// EndTimeGte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeGte(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time >= ?", endTime))
}

// EndTimeLt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeLt(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time < ?", endTime))
}

// EndTimeLte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeLte(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time <= ?", endTime))
}

// EndTimeNe is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) EndTimeNe(endTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("end_time != ?", endTime))
}

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) GetUpdater() ActivityUpdater {
	return NewActivityUpdater(qs.db)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OrderAscByActivityType is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderAscByActivityType() ActivityQuerySet {
	return qs.w(qs.db.Order("activity_type ASC"))
}

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

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

// OrderAscByEndTime is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderAscByEndTime() ActivityQuerySet {
	return qs.w(qs.db.Order("end_time ASC"))
}

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

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

// OrderAscByStartTime is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderAscByStartTime() ActivityQuerySet {
	return qs.w(qs.db.Order("start_time ASC"))
}

// OrderAscByState is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderAscByState() ActivityQuerySet {
	return qs.w(qs.db.Order("state ASC"))
}

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

// OrderDescByActivityType is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderDescByActivityType() ActivityQuerySet {
	return qs.w(qs.db.Order("activity_type DESC"))
}

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

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

// OrderDescByEndTime is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderDescByEndTime() ActivityQuerySet {
	return qs.w(qs.db.Order("end_time DESC"))
}

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

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

// OrderDescByStartTime is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderDescByStartTime() ActivityQuerySet {
	return qs.w(qs.db.Order("start_time DESC"))
}

// OrderDescByState is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) OrderDescByState() ActivityQuerySet {
	return qs.w(qs.db.Order("state DESC"))
}

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

// StartTimeEq is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeEq(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time = ?", startTime))
}

// StartTimeGt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeGt(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time > ?", startTime))
}

// StartTimeGte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeGte(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time >= ?", startTime))
}

// StartTimeLt is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeLt(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time < ?", startTime))
}

// StartTimeLte is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeLte(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time <= ?", startTime))
}

// StartTimeNe is an autogenerated method
// nolint: dupl
func (qs ActivityQuerySet) StartTimeNe(startTime time.Time) ActivityQuerySet {
	return qs.w(qs.db.Where("start_time != ?", startTime))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetActivityType is an autogenerated method
// nolint: dupl
func (u ActivityUpdater) SetActivityType(activityType uint32) ActivityUpdater {
	u.fields[string(ActivityDBSchema.ActivityType)] = activityType
	return u
}

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

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

// SetEndTime is an autogenerated method
// nolint: dupl
func (u ActivityUpdater) SetEndTime(endTime time.Time) ActivityUpdater {
	u.fields[string(ActivityDBSchema.EndTime)] = endTime
	return u
}

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

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

// SetStartTime is an autogenerated method
// nolint: dupl
func (u ActivityUpdater) SetStartTime(startTime time.Time) ActivityUpdater {
	u.fields[string(ActivityDBSchema.StartTime)] = startTime
	return u
}

// SetState is an autogenerated method
// nolint: dupl
func (u ActivityUpdater) SetState(state uint32) ActivityUpdater {
	u.fields[string(ActivityDBSchema.State)] = state
	return u
}

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

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

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

// ===== END of query set ActivityQuerySet

// ===== BEGIN of Activity modifiers

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

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

// ActivityDBSchema stores db field names of Activity
var ActivityDBSchema = struct {
	ID           ActivityDBSchemaField
	CreatedAt    ActivityDBSchemaField
	UpdatedAt    ActivityDBSchemaField
	DeletedAt    ActivityDBSchemaField
	Name         ActivityDBSchemaField
	ActivityType ActivityDBSchemaField
	State        ActivityDBSchemaField
	StartTime    ActivityDBSchemaField
	EndTime      ActivityDBSchemaField
}{

	ID:           ActivityDBSchemaField("id"),
	CreatedAt:    ActivityDBSchemaField("created_at"),
	UpdatedAt:    ActivityDBSchemaField("updated_at"),
	DeletedAt:    ActivityDBSchemaField("deleted_at"),
	Name:         ActivityDBSchemaField("name"),
	ActivityType: ActivityDBSchemaField("activity_type"),
	State:        ActivityDBSchemaField("state"),
	StartTime:    ActivityDBSchemaField("start_time"),
	EndTime:      ActivityDBSchemaField("end_time"),
}

// Update updates Activity fields by primary key
// nolint: dupl
func (o *Activity) Update(db *gorm.DB, fields ...ActivityDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":            o.ID,
		"created_at":    o.CreatedAt,
		"updated_at":    o.UpdatedAt,
		"deleted_at":    o.DeletedAt,
		"name":          o.Name,
		"activity_type": o.ActivityType,
		"state":         o.State,
		"start_time":    o.StartTime,
		"end_time":      o.EndTime,
	}
	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 Activity %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of Activity modifiers

// ===== BEGIN of query set CouponQuerySet

// CouponQuerySet is an queryset type for Coupon
type CouponQuerySet struct {
	db *gorm.DB
}

// NewCouponQuerySet constructs new CouponQuerySet
func NewCouponQuerySet(db *gorm.DB) CouponQuerySet {
	return CouponQuerySet{
		db: db.Model(&Coupon{}),
	}
}

func (qs CouponQuerySet) w(db *gorm.DB) CouponQuerySet {
	return NewCouponQuerySet(db)
}

func (qs CouponQuerySet) Select(fields ...CouponDBSchemaField) CouponQuerySet {
	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 *Coupon) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

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

// ActiveEndEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndEq(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end = ?", activeEnd))
}

// ActiveEndGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndGt(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end > ?", activeEnd))
}

// ActiveEndGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndGte(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end >= ?", activeEnd))
}

// ActiveEndLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndLt(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end < ?", activeEnd))
}

// ActiveEndLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndLte(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end <= ?", activeEnd))
}

// ActiveEndNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveEndNe(activeEnd time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_end != ?", activeEnd))
}

// ActiveStartEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartEq(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start = ?", activeStart))
}

// ActiveStartGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartGt(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start > ?", activeStart))
}

// ActiveStartGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartGte(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start >= ?", activeStart))
}

// ActiveStartLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartLt(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start < ?", activeStart))
}

// ActiveStartLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartLte(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start <= ?", activeStart))
}

// ActiveStartNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActiveStartNe(activeStart time.Time) CouponQuerySet {
	return qs.w(qs.db.Where("active_start != ?", activeStart))
}

// ActivityIdEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdEq(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id = ?", activityId))
}

// ActivityIdGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdGt(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id > ?", activityId))
}

// ActivityIdGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdGte(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id >= ?", activityId))
}

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

// ActivityIdLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdLt(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id < ?", activityId))
}

// ActivityIdLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdLte(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id <= ?", activityId))
}

// ActivityIdNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityIdNe(activityId uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_id != ?", activityId))
}

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

// ActivityTypeEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeEq(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type = ?", activityType))
}

// ActivityTypeGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeGt(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type > ?", activityType))
}

// ActivityTypeGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeGte(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type >= ?", activityType))
}

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

// ActivityTypeLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeLt(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type < ?", activityType))
}

// ActivityTypeLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeLte(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type <= ?", activityType))
}

// ActivityTypeNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) ActivityTypeNe(activityType uint32) CouponQuerySet {
	return qs.w(qs.db.Where("activity_type != ?", activityType))
}

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

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

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

// CouponTypeEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeEq(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type = ?", couponType))
}

// CouponTypeGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeGt(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type > ?", couponType))
}

// CouponTypeGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeGte(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type >= ?", couponType))
}

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

// CouponTypeLike is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeLike(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type LIKE ?", couponType))
}

// CouponTypeLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeLt(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type < ?", couponType))
}

// CouponTypeLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeLte(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type <= ?", couponType))
}

// CouponTypeNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeNe(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type != ?", couponType))
}

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

// CouponTypeNotlike is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) CouponTypeNotlike(couponType string) CouponQuerySet {
	return qs.w(qs.db.Where("coupon_type NOT LIKE ?", couponType))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) GetUpdater() CouponUpdater {
	return NewCouponUpdater(qs.db)
}

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

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

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

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

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

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

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

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

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

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

// MemberLevelIn is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) MemberLevelIn(memberLevel ...uint32) CouponQuerySet {
	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 CouponQuerySet) MemberLevelLt(memberLevel uint32) CouponQuerySet {
	return qs.w(qs.db.Where("member_level < ?", memberLevel))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OrderAscByActiveEnd is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByActiveEnd() CouponQuerySet {
	return qs.w(qs.db.Order("active_end ASC"))
}

// OrderAscByActiveStart is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByActiveStart() CouponQuerySet {
	return qs.w(qs.db.Order("active_start ASC"))
}

// OrderAscByActivityId is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByActivityId() CouponQuerySet {
	return qs.w(qs.db.Order("activity_id ASC"))
}

// OrderAscByActivityType is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByActivityType() CouponQuerySet {
	return qs.w(qs.db.Order("activity_type ASC"))
}

// OrderAscByCouponType is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByCouponType() CouponQuerySet {
	return qs.w(qs.db.Order("coupon_type ASC"))
}

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

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

// OrderAscByDescribe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByDescribe() CouponQuerySet {
	return qs.w(qs.db.Order("describe ASC"))
}

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

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

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

// OrderAscByOutCount is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByOutCount() CouponQuerySet {
	return qs.w(qs.db.Order("out_count ASC"))
}

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

// OrderAscByUsedCount is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByUsedCount() CouponQuerySet {
	return qs.w(qs.db.Order("used_count ASC"))
}

// OrderAscByValue is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderAscByValue() CouponQuerySet {
	return qs.w(qs.db.Order("value ASC"))
}

// OrderDescByActiveEnd is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByActiveEnd() CouponQuerySet {
	return qs.w(qs.db.Order("active_end DESC"))
}

// OrderDescByActiveStart is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByActiveStart() CouponQuerySet {
	return qs.w(qs.db.Order("active_start DESC"))
}

// OrderDescByActivityId is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByActivityId() CouponQuerySet {
	return qs.w(qs.db.Order("activity_id DESC"))
}

// OrderDescByActivityType is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByActivityType() CouponQuerySet {
	return qs.w(qs.db.Order("activity_type DESC"))
}

// OrderDescByCouponType is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByCouponType() CouponQuerySet {
	return qs.w(qs.db.Order("coupon_type DESC"))
}

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

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

// OrderDescByDescribe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByDescribe() CouponQuerySet {
	return qs.w(qs.db.Order("describe DESC"))
}

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

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

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

// OrderDescByOutCount is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByOutCount() CouponQuerySet {
	return qs.w(qs.db.Order("out_count DESC"))
}

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

// OrderDescByUsedCount is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByUsedCount() CouponQuerySet {
	return qs.w(qs.db.Order("used_count DESC"))
}

// OrderDescByValue is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OrderDescByValue() CouponQuerySet {
	return qs.w(qs.db.Order("value DESC"))
}

// OutCountEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountEq(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count = ?", outCount))
}

// OutCountGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountGt(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count > ?", outCount))
}

// OutCountGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountGte(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count >= ?", outCount))
}

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

// OutCountLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountLt(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count < ?", outCount))
}

// OutCountLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountLte(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count <= ?", outCount))
}

// OutCountNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) OutCountNe(outCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("out_count != ?", outCount))
}

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

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

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

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

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

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

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

// UsedCountEq is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountEq(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count = ?", usedCount))
}

// UsedCountGt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountGt(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count > ?", usedCount))
}

// UsedCountGte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountGte(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count >= ?", usedCount))
}

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

// UsedCountLt is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountLt(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count < ?", usedCount))
}

// UsedCountLte is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountLte(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count <= ?", usedCount))
}

// UsedCountNe is an autogenerated method
// nolint: dupl
func (qs CouponQuerySet) UsedCountNe(usedCount uint32) CouponQuerySet {
	return qs.w(qs.db.Where("used_count != ?", usedCount))
}

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

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

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

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

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

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

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

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

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

// SetActiveEnd is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetActiveEnd(activeEnd time.Time) CouponUpdater {
	u.fields[string(CouponDBSchema.ActiveEnd)] = activeEnd
	return u
}

// SetActiveStart is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetActiveStart(activeStart time.Time) CouponUpdater {
	u.fields[string(CouponDBSchema.ActiveStart)] = activeStart
	return u
}

// SetActivityId is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetActivityId(activityId uint32) CouponUpdater {
	u.fields[string(CouponDBSchema.ActivityId)] = activityId
	return u
}

// SetActivityType is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetActivityType(activityType uint32) CouponUpdater {
	u.fields[string(CouponDBSchema.ActivityType)] = activityType
	return u
}

// SetCouponType is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetCouponType(couponType string) CouponUpdater {
	u.fields[string(CouponDBSchema.CouponType)] = couponType
	return u
}

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

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

// SetDescribe is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetDescribe(describe string) CouponUpdater {
	u.fields[string(CouponDBSchema.Describe)] = describe
	return u
}

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

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

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

// SetOutCount is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetOutCount(outCount uint32) CouponUpdater {
	u.fields[string(CouponDBSchema.OutCount)] = outCount
	return u
}

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

// SetUsedCount is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetUsedCount(usedCount uint32) CouponUpdater {
	u.fields[string(CouponDBSchema.UsedCount)] = usedCount
	return u
}

// SetValue is an autogenerated method
// nolint: dupl
func (u CouponUpdater) SetValue(value uint32) CouponUpdater {
	u.fields[string(CouponDBSchema.Value)] = value
	return u
}

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

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

// ===== END of query set CouponQuerySet

// ===== BEGIN of Coupon modifiers

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

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

// CouponDBSchema stores db field names of Coupon
var CouponDBSchema = struct {
	ID           CouponDBSchemaField
	CreatedAt    CouponDBSchemaField
	UpdatedAt    CouponDBSchemaField
	DeletedAt    CouponDBSchemaField
	Name         CouponDBSchemaField
	Describe     CouponDBSchemaField
	CouponType   CouponDBSchemaField
	ActivityType CouponDBSchemaField
	ActivityId   CouponDBSchemaField
	Value        CouponDBSchemaField
	OutCount     CouponDBSchemaField
	UsedCount    CouponDBSchemaField
	ActiveStart  CouponDBSchemaField
	ActiveEnd    CouponDBSchemaField
	MemberLevel  CouponDBSchemaField
}{

	ID:           CouponDBSchemaField("id"),
	CreatedAt:    CouponDBSchemaField("created_at"),
	UpdatedAt:    CouponDBSchemaField("updated_at"),
	DeletedAt:    CouponDBSchemaField("deleted_at"),
	Name:         CouponDBSchemaField("name"),
	Describe:     CouponDBSchemaField("describe"),
	CouponType:   CouponDBSchemaField("coupon_type"),
	ActivityType: CouponDBSchemaField("activity_type"),
	ActivityId:   CouponDBSchemaField("activity_id"),
	Value:        CouponDBSchemaField("value"),
	OutCount:     CouponDBSchemaField("out_count"),
	UsedCount:    CouponDBSchemaField("used_count"),
	ActiveStart:  CouponDBSchemaField("active_start"),
	ActiveEnd:    CouponDBSchemaField("active_end"),
	MemberLevel:  CouponDBSchemaField("member_level"),
}

// Update updates Coupon fields by primary key
// nolint: dupl
func (o *Coupon) Update(db *gorm.DB, fields ...CouponDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":            o.ID,
		"created_at":    o.CreatedAt,
		"updated_at":    o.UpdatedAt,
		"deleted_at":    o.DeletedAt,
		"name":          o.Name,
		"describe":      o.Describe,
		"coupon_type":   o.CouponType,
		"activity_type": o.ActivityType,
		"activity_id":   o.ActivityId,
		"value":         o.Value,
		"out_count":     o.OutCount,
		"used_count":    o.UsedCount,
		"active_start":  o.ActiveStart,
		"active_end":    o.ActiveEnd,
		"member_level":  o.MemberLevel,
	}
	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 Coupon %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of Coupon modifiers

// ===== BEGIN of query set UserCouponQuerySet

// UserCouponQuerySet is an queryset type for UserCoupon
type UserCouponQuerySet struct {
	db *gorm.DB
}

// NewUserCouponQuerySet constructs new UserCouponQuerySet
func NewUserCouponQuerySet(db *gorm.DB) UserCouponQuerySet {
	return UserCouponQuerySet{
		db: db.Model(&UserCoupon{}),
	}
}

func (qs UserCouponQuerySet) w(db *gorm.DB) UserCouponQuerySet {
	return NewUserCouponQuerySet(db)
}

func (qs UserCouponQuerySet) Select(fields ...UserCouponDBSchemaField) UserCouponQuerySet {
	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 *UserCoupon) Create(db *gorm.DB) error {
	return db.Create(o).Error
}

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

// ActiveEndEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndEq(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end = ?", activeEnd))
}

// ActiveEndGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndGt(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end > ?", activeEnd))
}

// ActiveEndGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndGte(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end >= ?", activeEnd))
}

// ActiveEndLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndLt(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end < ?", activeEnd))
}

// ActiveEndLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndLte(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end <= ?", activeEnd))
}

// ActiveEndNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveEndNe(activeEnd time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_end != ?", activeEnd))
}

// ActiveStartEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartEq(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start = ?", activeStart))
}

// ActiveStartGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartGt(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start > ?", activeStart))
}

// ActiveStartGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartGte(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start >= ?", activeStart))
}

// ActiveStartLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartLt(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start < ?", activeStart))
}

// ActiveStartLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartLte(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start <= ?", activeStart))
}

// ActiveStartNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActiveStartNe(activeStart time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("active_start != ?", activeStart))
}

// ActivityIdEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdEq(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id = ?", activityId))
}

// ActivityIdGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdGt(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id > ?", activityId))
}

// ActivityIdGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdGte(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id >= ?", activityId))
}

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

// ActivityIdLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdLt(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id < ?", activityId))
}

// ActivityIdLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdLte(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id <= ?", activityId))
}

// ActivityIdNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityIdNe(activityId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_id != ?", activityId))
}

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

// ActivityTypeEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeEq(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type = ?", activityType))
}

// ActivityTypeGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeGt(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type > ?", activityType))
}

// ActivityTypeGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeGte(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type >= ?", activityType))
}

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

// ActivityTypeLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeLt(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type < ?", activityType))
}

// ActivityTypeLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeLte(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type <= ?", activityType))
}

// ActivityTypeNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) ActivityTypeNe(activityType uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("activity_type != ?", activityType))
}

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

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

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

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

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

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

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

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

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

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

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

// CouponIdEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdEq(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id = ?", couponId))
}

// CouponIdGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdGt(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id > ?", couponId))
}

// CouponIdGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdGte(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id >= ?", couponId))
}

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

// CouponIdLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdLt(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id < ?", couponId))
}

// CouponIdLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdLte(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id <= ?", couponId))
}

// CouponIdNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponIdNe(couponId uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_id != ?", couponId))
}

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

// CouponTypeEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeEq(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type = ?", couponType))
}

// CouponTypeGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeGt(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type > ?", couponType))
}

// CouponTypeGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeGte(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type >= ?", couponType))
}

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

// CouponTypeLike is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeLike(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type LIKE ?", couponType))
}

// CouponTypeLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeLt(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type < ?", couponType))
}

// CouponTypeLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeLte(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type <= ?", couponType))
}

// CouponTypeNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeNe(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type != ?", couponType))
}

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

// CouponTypeNotlike is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) CouponTypeNotlike(couponType string) UserCouponQuerySet {
	return qs.w(qs.db.Where("coupon_type NOT LIKE ?", couponType))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) GetUpdater() UserCouponUpdater {
	return NewUserCouponUpdater(qs.db)
}

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

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

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

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

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

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

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

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

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

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

// MemberLevelIn is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) MemberLevelIn(memberLevel ...uint32) UserCouponQuerySet {
	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 UserCouponQuerySet) MemberLevelLt(memberLevel uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("member_level < ?", memberLevel))
}

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

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

// MemberLevelNotIn is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) MemberLevelNotIn(memberLevel ...uint32) UserCouponQuerySet {
	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 UserCouponQuerySet) Offset(offset int) UserCouponQuerySet {
	return qs.w(qs.db.Offset(offset))
}

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

// OrderAscByActiveEnd is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByActiveEnd() UserCouponQuerySet {
	return qs.w(qs.db.Order("active_end ASC"))
}

// OrderAscByActiveStart is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByActiveStart() UserCouponQuerySet {
	return qs.w(qs.db.Order("active_start ASC"))
}

// OrderAscByActivityId is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByActivityId() UserCouponQuerySet {
	return qs.w(qs.db.Order("activity_id ASC"))
}

// OrderAscByActivityType is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByActivityType() UserCouponQuerySet {
	return qs.w(qs.db.Order("activity_type ASC"))
}

// OrderAscByApproach is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByApproach() UserCouponQuerySet {
	return qs.w(qs.db.Order("approach ASC"))
}

// OrderAscByCouponId is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByCouponId() UserCouponQuerySet {
	return qs.w(qs.db.Order("coupon_id ASC"))
}

// OrderAscByCouponType is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByCouponType() UserCouponQuerySet {
	return qs.w(qs.db.Order("coupon_type ASC"))
}

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

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

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

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

// OrderAscByPromotionalSales is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByPromotionalSales() UserCouponQuerySet {
	return qs.w(qs.db.Order("promotional_sales ASC"))
}

// OrderAscByRedeemCode is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByRedeemCode() UserCouponQuerySet {
	return qs.w(qs.db.Order("redeem_code ASC"))
}

// OrderAscByState is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByState() UserCouponQuerySet {
	return qs.w(qs.db.Order("state ASC"))
}

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

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

// OrderAscByUseTime is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByUseTime() UserCouponQuerySet {
	return qs.w(qs.db.Order("use_time ASC"))
}

// OrderAscByValue is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderAscByValue() UserCouponQuerySet {
	return qs.w(qs.db.Order("value ASC"))
}

// OrderDescByActiveEnd is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByActiveEnd() UserCouponQuerySet {
	return qs.w(qs.db.Order("active_end DESC"))
}

// OrderDescByActiveStart is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByActiveStart() UserCouponQuerySet {
	return qs.w(qs.db.Order("active_start DESC"))
}

// OrderDescByActivityId is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByActivityId() UserCouponQuerySet {
	return qs.w(qs.db.Order("activity_id DESC"))
}

// OrderDescByActivityType is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByActivityType() UserCouponQuerySet {
	return qs.w(qs.db.Order("activity_type DESC"))
}

// OrderDescByApproach is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByApproach() UserCouponQuerySet {
	return qs.w(qs.db.Order("approach DESC"))
}

// OrderDescByCouponId is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByCouponId() UserCouponQuerySet {
	return qs.w(qs.db.Order("coupon_id DESC"))
}

// OrderDescByCouponType is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByCouponType() UserCouponQuerySet {
	return qs.w(qs.db.Order("coupon_type DESC"))
}

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

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

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

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

// OrderDescByPromotionalSales is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByPromotionalSales() UserCouponQuerySet {
	return qs.w(qs.db.Order("promotional_sales DESC"))
}

// OrderDescByRedeemCode is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByRedeemCode() UserCouponQuerySet {
	return qs.w(qs.db.Order("redeem_code DESC"))
}

// OrderDescByState is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByState() UserCouponQuerySet {
	return qs.w(qs.db.Order("state DESC"))
}

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

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

// OrderDescByUseTime is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByUseTime() UserCouponQuerySet {
	return qs.w(qs.db.Order("use_time DESC"))
}

// OrderDescByValue is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) OrderDescByValue() UserCouponQuerySet {
	return qs.w(qs.db.Order("value DESC"))
}

// PromotionalSalesEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesEq(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales = ?", promotionalSales))
}

// PromotionalSalesGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesGt(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales > ?", promotionalSales))
}

// PromotionalSalesGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesGte(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales >= ?", promotionalSales))
}

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

// PromotionalSalesLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesLt(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales < ?", promotionalSales))
}

// PromotionalSalesLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesLte(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales <= ?", promotionalSales))
}

// PromotionalSalesNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) PromotionalSalesNe(promotionalSales uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("promotional_sales != ?", promotionalSales))
}

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

// RedeemCodeEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeEq(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code = ?", redeemCode))
}

// RedeemCodeGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeGt(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code > ?", redeemCode))
}

// RedeemCodeGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeGte(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code >= ?", redeemCode))
}

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

// RedeemCodeLike is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeLike(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code LIKE ?", redeemCode))
}

// RedeemCodeLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeLt(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code < ?", redeemCode))
}

// RedeemCodeLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeLte(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code <= ?", redeemCode))
}

// RedeemCodeNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeNe(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code != ?", redeemCode))
}

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

// RedeemCodeNotlike is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) RedeemCodeNotlike(redeemCode string) UserCouponQuerySet {
	return qs.w(qs.db.Where("redeem_code NOT LIKE ?", redeemCode))
}

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

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

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

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

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

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

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

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

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

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

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

// UidIn is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UidIn(uid ...uint32) UserCouponQuerySet {
	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 UserCouponQuerySet) UidLt(uid uint32) UserCouponQuerySet {
	return qs.w(qs.db.Where("uid < ?", uid))
}

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

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

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

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

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

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

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

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

// UseTimeEq is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeEq(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time = ?", useTime))
}

// UseTimeGt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeGt(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time > ?", useTime))
}

// UseTimeGte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeGte(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time >= ?", useTime))
}

// UseTimeLt is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeLt(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time < ?", useTime))
}

// UseTimeLte is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeLte(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time <= ?", useTime))
}

// UseTimeNe is an autogenerated method
// nolint: dupl
func (qs UserCouponQuerySet) UseTimeNe(useTime time.Time) UserCouponQuerySet {
	return qs.w(qs.db.Where("use_time != ?", useTime))
}

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

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

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

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

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

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

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

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

// SetActiveEnd is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetActiveEnd(activeEnd time.Time) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.ActiveEnd)] = activeEnd
	return u
}

// SetActiveStart is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetActiveStart(activeStart time.Time) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.ActiveStart)] = activeStart
	return u
}

// SetActivityId is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetActivityId(activityId uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.ActivityId)] = activityId
	return u
}

// SetActivityType is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetActivityType(activityType uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.ActivityType)] = activityType
	return u
}

// SetApproach is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetApproach(approach uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.Approach)] = approach
	return u
}

// SetCouponId is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetCouponId(couponId uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.CouponId)] = couponId
	return u
}

// SetCouponType is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetCouponType(couponType string) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.CouponType)] = couponType
	return u
}

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

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

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

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

// SetPromotionalSales is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetPromotionalSales(promotionalSales uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.PromotionalSales)] = promotionalSales
	return u
}

// SetRedeemCode is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetRedeemCode(redeemCode string) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.RedeemCode)] = redeemCode
	return u
}

// SetState is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetState(state uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.State)] = state
	return u
}

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

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

// SetUseTime is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetUseTime(useTime time.Time) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.UseTime)] = useTime
	return u
}

// SetValue is an autogenerated method
// nolint: dupl
func (u UserCouponUpdater) SetValue(value uint32) UserCouponUpdater {
	u.fields[string(UserCouponDBSchema.Value)] = value
	return u
}

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

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

// ===== END of query set UserCouponQuerySet

// ===== BEGIN of UserCoupon modifiers

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

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

// UserCouponDBSchema stores db field names of UserCoupon
var UserCouponDBSchema = struct {
	ID               UserCouponDBSchemaField
	CreatedAt        UserCouponDBSchemaField
	UpdatedAt        UserCouponDBSchemaField
	DeletedAt        UserCouponDBSchemaField
	Uid              UserCouponDBSchemaField
	CouponId         UserCouponDBSchemaField
	CouponType       UserCouponDBSchemaField
	ActivityType     UserCouponDBSchemaField
	ActivityId       UserCouponDBSchemaField
	Value            UserCouponDBSchemaField
	State            UserCouponDBSchemaField
	ActiveStart      UserCouponDBSchemaField
	ActiveEnd        UserCouponDBSchemaField
	UseTime          UserCouponDBSchemaField
	MemberLevel      UserCouponDBSchemaField
	Approach         UserCouponDBSchemaField
	PromotionalSales UserCouponDBSchemaField
	RedeemCode       UserCouponDBSchemaField
}{

	ID:               UserCouponDBSchemaField("id"),
	CreatedAt:        UserCouponDBSchemaField("created_at"),
	UpdatedAt:        UserCouponDBSchemaField("updated_at"),
	DeletedAt:        UserCouponDBSchemaField("deleted_at"),
	Uid:              UserCouponDBSchemaField("uid"),
	CouponId:         UserCouponDBSchemaField("coupon_id"),
	CouponType:       UserCouponDBSchemaField("coupon_type"),
	ActivityType:     UserCouponDBSchemaField("activity_type"),
	ActivityId:       UserCouponDBSchemaField("activity_id"),
	Value:            UserCouponDBSchemaField("value"),
	State:            UserCouponDBSchemaField("state"),
	ActiveStart:      UserCouponDBSchemaField("active_start"),
	ActiveEnd:        UserCouponDBSchemaField("active_end"),
	UseTime:          UserCouponDBSchemaField("use_time"),
	MemberLevel:      UserCouponDBSchemaField("member_level"),
	Approach:         UserCouponDBSchemaField("approach"),
	PromotionalSales: UserCouponDBSchemaField("promotional_sales"),
	RedeemCode:       UserCouponDBSchemaField("redeem_code"),
}

// Update updates UserCoupon fields by primary key
// nolint: dupl
func (o *UserCoupon) Update(db *gorm.DB, fields ...UserCouponDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":                o.ID,
		"created_at":        o.CreatedAt,
		"updated_at":        o.UpdatedAt,
		"deleted_at":        o.DeletedAt,
		"uid":               o.Uid,
		"coupon_id":         o.CouponId,
		"coupon_type":       o.CouponType,
		"activity_type":     o.ActivityType,
		"activity_id":       o.ActivityId,
		"value":             o.Value,
		"state":             o.State,
		"active_start":      o.ActiveStart,
		"active_end":        o.ActiveEnd,
		"use_time":          o.UseTime,
		"member_level":      o.MemberLevel,
		"approach":          o.Approach,
		"promotional_sales": o.PromotionalSales,
		"redeem_code":       o.RedeemCode,
	}
	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 UserCoupon %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of UserCoupon modifiers

// ===== END of all query sets