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

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

	"gorm.io/gorm"
)

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

// ===== BEGIN of query set ImportIntoPrecheckTaskQuerySet

// ImportIntoPrecheckTaskQuerySet is an queryset type for ImportIntoPrecheckTask
type ImportIntoPrecheckTaskQuerySet struct {
	db *gorm.DB
}

// NewImportIntoPrecheckTaskQuerySet constructs new ImportIntoPrecheckTaskQuerySet
func NewImportIntoPrecheckTaskQuerySet(db *gorm.DB) ImportIntoPrecheckTaskQuerySet {
	return ImportIntoPrecheckTaskQuerySet{
		db: db.Model(&ImportIntoPrecheckTask{}),
	}
}

func (qs ImportIntoPrecheckTaskQuerySet) w(db *gorm.DB) ImportIntoPrecheckTaskQuerySet {
	return NewImportIntoPrecheckTaskQuerySet(db)
}

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

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

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

// ClusterIDEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDEq(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id = ?", clusterID))
}

// ClusterIDGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDGt(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id > ?", clusterID))
}

// ClusterIDGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDGte(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id >= ?", clusterID))
}

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

// ClusterIDLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDLt(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id < ?", clusterID))
}

// ClusterIDLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDLte(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id <= ?", clusterID))
}

// ClusterIDNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) ClusterIDNe(clusterID ID) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id != ?", clusterID))
}

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

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

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

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

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

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

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

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

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

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

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

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) GetUpdater() ImportIntoPrecheckTaskUpdater {
	return NewImportIntoPrecheckTaskUpdater(qs.db)
}

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

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

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

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

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

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

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

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

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

// OrderAscByClusterID is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) OrderAscByClusterID() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Order("cluster_id ASC"))
}

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

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

// OrderAscBySourceType is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) OrderAscBySourceType() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Order("source_type ASC"))
}

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

// OrderDescByClusterID is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) OrderDescByClusterID() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Order("cluster_id DESC"))
}

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

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

// OrderDescBySourceType is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) OrderDescBySourceType() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Order("source_type DESC"))
}

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

// SourceTypeEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeEq(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type = ?", sourceType))
}

// SourceTypeGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeGt(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type > ?", sourceType))
}

// SourceTypeGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeGte(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type >= ?", sourceType))
}

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

// SourceTypeLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeLike(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type LIKE ?", sourceType))
}

// SourceTypeLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeLt(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type < ?", sourceType))
}

// SourceTypeLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeLte(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type <= ?", sourceType))
}

// SourceTypeNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeNe(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type != ?", sourceType))
}

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

// SourceTypeNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) SourceTypeNotlike(sourceType string) ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("source_type NOT LIKE ?", sourceType))
}

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

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

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

// UpdatedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) UpdatedAtIsNotNull() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("updated_at IS NOT NULL"))
}

// UpdatedAtIsNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoPrecheckTaskQuerySet) UpdatedAtIsNull() ImportIntoPrecheckTaskQuerySet {
	return qs.w(qs.db.Where("updated_at IS NULL"))
}

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

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

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

// SetClusterID is an autogenerated method
// nolint: dupl
func (u ImportIntoPrecheckTaskUpdater) SetClusterID(clusterID ID) ImportIntoPrecheckTaskUpdater {
	u.fields[string(ImportIntoPrecheckTaskDBSchema.ClusterID)] = clusterID
	return u
}

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

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

// SetSourceType is an autogenerated method
// nolint: dupl
func (u ImportIntoPrecheckTaskUpdater) SetSourceType(sourceType string) ImportIntoPrecheckTaskUpdater {
	u.fields[string(ImportIntoPrecheckTaskDBSchema.SourceType)] = sourceType
	return u
}

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

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

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

// ===== END of query set ImportIntoPrecheckTaskQuerySet

// ===== BEGIN of ImportIntoPrecheckTask modifiers

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

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

// ImportIntoPrecheckTaskDBSchema stores db field names of ImportIntoPrecheckTask
var ImportIntoPrecheckTaskDBSchema = struct {
	ID         ImportIntoPrecheckTaskDBSchemaField
	CreatedAt  ImportIntoPrecheckTaskDBSchemaField
	UpdatedAt  ImportIntoPrecheckTaskDBSchemaField
	ClusterID  ImportIntoPrecheckTaskDBSchemaField
	SourceType ImportIntoPrecheckTaskDBSchemaField
}{

	ID:         ImportIntoPrecheckTaskDBSchemaField("id"),
	CreatedAt:  ImportIntoPrecheckTaskDBSchemaField("created_at"),
	UpdatedAt:  ImportIntoPrecheckTaskDBSchemaField("updated_at"),
	ClusterID:  ImportIntoPrecheckTaskDBSchemaField("cluster_id"),
	SourceType: ImportIntoPrecheckTaskDBSchemaField("source_type"),
}

// Update updates ImportIntoPrecheckTask fields by primary key
// nolint: dupl
func (o *ImportIntoPrecheckTask) Update(db *gorm.DB, fields ...ImportIntoPrecheckTaskDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":          o.ID,
		"created_at":  o.CreatedAt,
		"updated_at":  o.UpdatedAt,
		"cluster_id":  o.ClusterID,
		"source_type": o.SourceType,
	}
	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 ImportIntoPrecheckTask %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of ImportIntoPrecheckTask modifiers

// ===== BEGIN of query set ImportIntoTaskQuerySet

// ImportIntoTaskQuerySet is an queryset type for ImportIntoTask
type ImportIntoTaskQuerySet struct {
	db *gorm.DB
}

// NewImportIntoTaskQuerySet constructs new ImportIntoTaskQuerySet
func NewImportIntoTaskQuerySet(db *gorm.DB) ImportIntoTaskQuerySet {
	return ImportIntoTaskQuerySet{
		db: db.Model(&ImportIntoTask{}),
	}
}

func (qs ImportIntoTaskQuerySet) w(db *gorm.DB) ImportIntoTaskQuerySet {
	return NewImportIntoTaskQuerySet(db)
}

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

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

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

// ArchTypeEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeEq(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type = ?", archType))
}

// ArchTypeGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeGt(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type > ?", archType))
}

// ArchTypeGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeGte(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type >= ?", archType))
}

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

// ArchTypeLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeLike(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type LIKE ?", archType))
}

// ArchTypeLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeLt(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type < ?", archType))
}

// ArchTypeLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeLte(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type <= ?", archType))
}

// ArchTypeNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeNe(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type != ?", archType))
}

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

// ArchTypeNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ArchTypeNotlike(archType ArchType) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("arch_type NOT LIKE ?", archType))
}

// ClusterIDEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDEq(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id = ?", clusterID))
}

// ClusterIDGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDGt(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id > ?", clusterID))
}

// ClusterIDGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDGte(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id >= ?", clusterID))
}

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

// ClusterIDLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDLt(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id < ?", clusterID))
}

// ClusterIDLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDLte(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id <= ?", clusterID))
}

// ClusterIDNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ClusterIDNe(clusterID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("cluster_id != ?", clusterID))
}

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

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

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

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

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

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

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

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

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

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

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

// CreatorIDEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDEq(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id = ?", creatorID))
}

// CreatorIDGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDGt(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id > ?", creatorID))
}

// CreatorIDGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDGte(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id >= ?", creatorID))
}

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

// CreatorIDLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDLt(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id < ?", creatorID))
}

// CreatorIDLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDLte(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id <= ?", creatorID))
}

// CreatorIDNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CreatorIDNe(creatorID uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("creator_id != ?", creatorID))
}

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

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

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

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

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

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

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

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

// CustomCSVFormatEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatEq(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format = ?", customCSVFormat))
}

// CustomCSVFormatGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatGt(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format > ?", customCSVFormat))
}

// CustomCSVFormatGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatGte(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format >= ?", customCSVFormat))
}

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

// CustomCSVFormatLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatLike(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format LIKE ?", customCSVFormat))
}

// CustomCSVFormatLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatLt(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format < ?", customCSVFormat))
}

// CustomCSVFormatLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatLte(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format <= ?", customCSVFormat))
}

// CustomCSVFormatNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatNe(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format != ?", customCSVFormat))
}

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

// CustomCSVFormatNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomCSVFormatNotlike(customCSVFormat string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_csv_format NOT LIKE ?", customCSVFormat))
}

// CustomStatusRegisteredEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRegisteredEq(customStatusRegistered bool) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_registered = ?", customStatusRegistered))
}

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

// CustomStatusRegisteredNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRegisteredNe(customStatusRegistered bool) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_registered != ?", customStatusRegistered))
}

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

// CustomStatusRetryAtEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtEq(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at = ?", customStatusRetryAt))
}

// CustomStatusRetryAtGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtGt(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at > ?", customStatusRetryAt))
}

// CustomStatusRetryAtGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtGte(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at >= ?", customStatusRetryAt))
}

// CustomStatusRetryAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtIsNotNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at IS NOT NULL"))
}

// CustomStatusRetryAtIsNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtIsNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at IS NULL"))
}

// CustomStatusRetryAtLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtLt(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at < ?", customStatusRetryAt))
}

// CustomStatusRetryAtLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtLte(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at <= ?", customStatusRetryAt))
}

// CustomStatusRetryAtNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) CustomStatusRetryAtNe(customStatusRetryAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("custom_status_retry_at != ?", customStatusRetryAt))
}

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

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

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

// FinishedAtEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtEq(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at = ?", finishedAt))
}

// FinishedAtGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtGt(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at > ?", finishedAt))
}

// FinishedAtGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtGte(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at >= ?", finishedAt))
}

// FinishedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtIsNotNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at IS NOT NULL"))
}

// FinishedAtIsNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtIsNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at IS NULL"))
}

// FinishedAtLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtLt(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at < ?", finishedAt))
}

// FinishedAtLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtLte(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at <= ?", finishedAt))
}

// FinishedAtNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) FinishedAtNe(finishedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("finished_at != ?", finishedAt))
}

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

// GetUpdater is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GetUpdater() ImportIntoTaskUpdater {
	return NewImportIntoTaskUpdater(qs.db)
}

// GroupKeyEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyEq(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key = ?", groupKey))
}

// GroupKeyGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyGt(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key > ?", groupKey))
}

// GroupKeyGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyGte(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key >= ?", groupKey))
}

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

// GroupKeyLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyLike(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key LIKE ?", groupKey))
}

// GroupKeyLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyLt(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key < ?", groupKey))
}

// GroupKeyLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyLte(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key <= ?", groupKey))
}

// GroupKeyNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyNe(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key != ?", groupKey))
}

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

// GroupKeyNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) GroupKeyNotlike(groupKey string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("group_key NOT LIKE ?", groupKey))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NameIn is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) NameIn(name ...string) ImportIntoTaskQuerySet {
	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 ImportIntoTaskQuerySet) NameLike(name string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("name LIKE ?", name))
}

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

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

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

// NameNotIn is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) NameNotIn(name ...string) ImportIntoTaskQuerySet {
	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 ImportIntoTaskQuerySet) NameNotlike(name string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("name NOT LIKE ?", name))
}

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

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

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

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

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

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

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

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

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

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

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

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

// OrderAscByArchType is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByArchType() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("arch_type ASC"))
}

// OrderAscByClusterID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByClusterID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("cluster_id ASC"))
}

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

// OrderAscByCreator is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByCreator() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("creator ASC"))
}

// OrderAscByCreatorID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByCreatorID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("creator_id ASC"))
}

// OrderAscByCustomCSVFormat is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByCustomCSVFormat() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_csv_format ASC"))
}

// OrderAscByCustomStatusRegistered is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByCustomStatusRegistered() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_status_registered ASC"))
}

// OrderAscByCustomStatusRetryAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByCustomStatusRetryAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_status_retry_at ASC"))
}

// OrderAscByFinishedAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByFinishedAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("finished_at ASC"))
}

// OrderAscByGroupKey is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByGroupKey() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("group_key ASC"))
}

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

// OrderAscByMessage is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByMessage() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("message ASC"))
}

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

// OrderAscByOptions is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByOptions() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("options ASC"))
}

// OrderAscByProjectID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByProjectID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("project_id ASC"))
}

// OrderAscByServerTier is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByServerTier() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("server_tier ASC"))
}

// OrderAscBySourceURI is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscBySourceURI() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("source_uri ASC"))
}

// OrderAscByStartedAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByStartedAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("started_at ASC"))
}

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

// OrderAscByTargetPassword is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByTargetPassword() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("target_password ASC"))
}

// OrderAscByTargetUsername is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByTargetUsername() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("target_username ASC"))
}

// OrderAscByTenantID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByTenantID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("tenant_id ASC"))
}

// OrderAscByTotalFiles is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByTotalFiles() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("total_files ASC"))
}

// OrderAscByTotalSize is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByTotalSize() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("total_size ASC"))
}

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

// OrderAscByVersioning is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderAscByVersioning() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("versioning ASC"))
}

// OrderDescByArchType is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByArchType() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("arch_type DESC"))
}

// OrderDescByClusterID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByClusterID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("cluster_id DESC"))
}

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

// OrderDescByCreator is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByCreator() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("creator DESC"))
}

// OrderDescByCreatorID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByCreatorID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("creator_id DESC"))
}

// OrderDescByCustomCSVFormat is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByCustomCSVFormat() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_csv_format DESC"))
}

// OrderDescByCustomStatusRegistered is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByCustomStatusRegistered() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_status_registered DESC"))
}

// OrderDescByCustomStatusRetryAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByCustomStatusRetryAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("custom_status_retry_at DESC"))
}

// OrderDescByFinishedAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByFinishedAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("finished_at DESC"))
}

// OrderDescByGroupKey is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByGroupKey() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("group_key DESC"))
}

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

// OrderDescByMessage is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByMessage() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("message DESC"))
}

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

// OrderDescByOptions is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByOptions() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("options DESC"))
}

// OrderDescByProjectID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByProjectID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("project_id DESC"))
}

// OrderDescByServerTier is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByServerTier() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("server_tier DESC"))
}

// OrderDescBySourceURI is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescBySourceURI() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("source_uri DESC"))
}

// OrderDescByStartedAt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByStartedAt() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("started_at DESC"))
}

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

// OrderDescByTargetPassword is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByTargetPassword() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("target_password DESC"))
}

// OrderDescByTargetUsername is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByTargetUsername() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("target_username DESC"))
}

// OrderDescByTenantID is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByTenantID() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("tenant_id DESC"))
}

// OrderDescByTotalFiles is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByTotalFiles() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("total_files DESC"))
}

// OrderDescByTotalSize is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByTotalSize() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("total_size DESC"))
}

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

// OrderDescByVersioning is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) OrderDescByVersioning() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Order("versioning DESC"))
}

// PreloadImportResults is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) PreloadImportResults() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Preload("ImportResults"))
}

// ProjectIDEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDEq(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id = ?", projectID))
}

// ProjectIDGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDGt(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id > ?", projectID))
}

// ProjectIDGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDGte(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id >= ?", projectID))
}

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

// ProjectIDLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDLt(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id < ?", projectID))
}

// ProjectIDLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDLte(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id <= ?", projectID))
}

// ProjectIDNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ProjectIDNe(projectID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("project_id != ?", projectID))
}

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

// ServerTierEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierEq(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier = ?", serverTier))
}

// ServerTierGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierGt(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier > ?", serverTier))
}

// ServerTierGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierGte(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier >= ?", serverTier))
}

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

// ServerTierLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierLike(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier LIKE ?", serverTier))
}

// ServerTierLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierLt(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier < ?", serverTier))
}

// ServerTierLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierLte(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier <= ?", serverTier))
}

// ServerTierNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierNe(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier != ?", serverTier))
}

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

// ServerTierNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) ServerTierNotlike(serverTier string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("server_tier NOT LIKE ?", serverTier))
}

// SourceURIEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURIEq(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri = ?", sourceURI))
}

// SourceURIGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURIGt(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri > ?", sourceURI))
}

// SourceURIGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURIGte(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri >= ?", sourceURI))
}

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

// SourceURILike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURILike(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri LIKE ?", sourceURI))
}

// SourceURILt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURILt(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri < ?", sourceURI))
}

// SourceURILte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURILte(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri <= ?", sourceURI))
}

// SourceURINe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURINe(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri != ?", sourceURI))
}

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

// SourceURINotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) SourceURINotlike(sourceURI string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("source_uri NOT LIKE ?", sourceURI))
}

// StartedAtEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtEq(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at = ?", startedAt))
}

// StartedAtGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtGt(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at > ?", startedAt))
}

// StartedAtGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtGte(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at >= ?", startedAt))
}

// StartedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtIsNotNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at IS NOT NULL"))
}

// StartedAtIsNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtIsNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at IS NULL"))
}

// StartedAtLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtLt(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at < ?", startedAt))
}

// StartedAtLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtLte(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at <= ?", startedAt))
}

// StartedAtNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StartedAtNe(startedAt time.Time) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("started_at != ?", startedAt))
}

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

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

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

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

// StatusLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StatusLike(status ImportIntoStatus) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("status LIKE ?", status))
}

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

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

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

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

// StatusNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) StatusNotlike(status ImportIntoStatus) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("status NOT LIKE ?", status))
}

// TargetPasswordEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordEq(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password = ?", targetPassword))
}

// TargetPasswordGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordGt(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password > ?", targetPassword))
}

// TargetPasswordGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordGte(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password >= ?", targetPassword))
}

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

// TargetPasswordLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordLike(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password LIKE ?", targetPassword))
}

// TargetPasswordLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordLt(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password < ?", targetPassword))
}

// TargetPasswordLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordLte(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password <= ?", targetPassword))
}

// TargetPasswordNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordNe(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password != ?", targetPassword))
}

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

// TargetPasswordNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetPasswordNotlike(targetPassword string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_password NOT LIKE ?", targetPassword))
}

// TargetUsernameEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameEq(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username = ?", targetUsername))
}

// TargetUsernameGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameGt(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username > ?", targetUsername))
}

// TargetUsernameGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameGte(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username >= ?", targetUsername))
}

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

// TargetUsernameLike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameLike(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username LIKE ?", targetUsername))
}

// TargetUsernameLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameLt(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username < ?", targetUsername))
}

// TargetUsernameLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameLte(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username <= ?", targetUsername))
}

// TargetUsernameNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameNe(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username != ?", targetUsername))
}

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

// TargetUsernameNotlike is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TargetUsernameNotlike(targetUsername string) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("target_username NOT LIKE ?", targetUsername))
}

// TenantIDEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDEq(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id = ?", tenantID))
}

// TenantIDGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDGt(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id > ?", tenantID))
}

// TenantIDGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDGte(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id >= ?", tenantID))
}

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

// TenantIDLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDLt(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id < ?", tenantID))
}

// TenantIDLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDLte(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id <= ?", tenantID))
}

// TenantIDNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TenantIDNe(tenantID ID) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("tenant_id != ?", tenantID))
}

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

// TotalFilesEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesEq(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files = ?", totalFiles))
}

// TotalFilesGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesGt(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files > ?", totalFiles))
}

// TotalFilesGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesGte(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files >= ?", totalFiles))
}

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

// TotalFilesLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesLt(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files < ?", totalFiles))
}

// TotalFilesLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesLte(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files <= ?", totalFiles))
}

// TotalFilesNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalFilesNe(totalFiles uint32) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_files != ?", totalFiles))
}

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

// TotalSizeEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeEq(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size = ?", totalSize))
}

// TotalSizeGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeGt(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size > ?", totalSize))
}

// TotalSizeGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeGte(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size >= ?", totalSize))
}

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

// TotalSizeLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeLt(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size < ?", totalSize))
}

// TotalSizeLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeLte(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size <= ?", totalSize))
}

// TotalSizeNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) TotalSizeNe(totalSize uint64) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("total_size != ?", totalSize))
}

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

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

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

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

// UpdatedAtIsNotNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) UpdatedAtIsNotNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("updated_at IS NOT NULL"))
}

// UpdatedAtIsNull is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) UpdatedAtIsNull() ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("updated_at IS NULL"))
}

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

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

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

// VersioningEq is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningEq(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning = ?", versioning))
}

// VersioningGt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningGt(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning > ?", versioning))
}

// VersioningGte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningGte(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning >= ?", versioning))
}

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

// VersioningLt is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningLt(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning < ?", versioning))
}

// VersioningLte is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningLte(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning <= ?", versioning))
}

// VersioningNe is an autogenerated method
// nolint: dupl
func (qs ImportIntoTaskQuerySet) VersioningNe(versioning int) ImportIntoTaskQuerySet {
	return qs.w(qs.db.Where("versioning != ?", versioning))
}

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

// SetArchType is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetArchType(archType ArchType) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.ArchType)] = archType
	return u
}

// SetClusterID is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetClusterID(clusterID ID) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.ClusterID)] = clusterID
	return u
}

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

// SetCreator is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetCreator(creator string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.Creator)] = creator
	return u
}

// SetCreatorID is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetCreatorID(creatorID uint64) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.CreatorID)] = creatorID
	return u
}

// SetCustomCSVFormat is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetCustomCSVFormat(customCSVFormat string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.CustomCSVFormat)] = customCSVFormat
	return u
}

// SetCustomStatusRegistered is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetCustomStatusRegistered(customStatusRegistered bool) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.CustomStatusRegistered)] = customStatusRegistered
	return u
}

// SetCustomStatusRetryAt is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetCustomStatusRetryAt(customStatusRetryAt *time.Time) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.CustomStatusRetryAt)] = customStatusRetryAt
	return u
}

// SetFinishedAt is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetFinishedAt(finishedAt *time.Time) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.FinishedAt)] = finishedAt
	return u
}

// SetGroupKey is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetGroupKey(groupKey string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.GroupKey)] = groupKey
	return u
}

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

// SetImportResults is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetImportResults(importResults ImportIntoSubTasks) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.ImportResults)] = importResults
	return u
}

// SetMessage is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetMessage(message string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.Message)] = message
	return u
}

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

// SetOptions is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetOptions(options string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.Options)] = options
	return u
}

// SetProjectID is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetProjectID(projectID ID) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.ProjectID)] = projectID
	return u
}

// SetServerTier is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetServerTier(serverTier string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.ServerTier)] = serverTier
	return u
}

// SetSourceURI is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetSourceURI(sourceURI string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.SourceURI)] = sourceURI
	return u
}

// SetStartedAt is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetStartedAt(startedAt *time.Time) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.StartedAt)] = startedAt
	return u
}

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

// SetTargetPassword is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetTargetPassword(targetPassword string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.TargetPassword)] = targetPassword
	return u
}

// SetTargetUsername is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetTargetUsername(targetUsername string) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.TargetUsername)] = targetUsername
	return u
}

// SetTenantID is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetTenantID(tenantID ID) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.TenantID)] = tenantID
	return u
}

// SetTotalFiles is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetTotalFiles(totalFiles uint32) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.TotalFiles)] = totalFiles
	return u
}

// SetTotalSize is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetTotalSize(totalSize uint64) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.TotalSize)] = totalSize
	return u
}

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

// SetVersioning is an autogenerated method
// nolint: dupl
func (u ImportIntoTaskUpdater) SetVersioning(versioning int) ImportIntoTaskUpdater {
	u.fields[string(ImportIntoTaskDBSchema.Versioning)] = versioning
	return u
}

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

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

// ===== END of query set ImportIntoTaskQuerySet

// ===== BEGIN of ImportIntoTask modifiers

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

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

// ImportIntoTaskDBSchema stores db field names of ImportIntoTask
var ImportIntoTaskDBSchema = struct {
	ID                     ImportIntoTaskDBSchemaField
	CreatedAt              ImportIntoTaskDBSchemaField
	UpdatedAt              ImportIntoTaskDBSchemaField
	Versioning             ImportIntoTaskDBSchemaField
	Name                   ImportIntoTaskDBSchemaField
	ClusterID              ImportIntoTaskDBSchemaField
	ProjectID              ImportIntoTaskDBSchemaField
	TenantID               ImportIntoTaskDBSchemaField
	Status                 ImportIntoTaskDBSchemaField
	Message                ImportIntoTaskDBSchemaField
	StartedAt              ImportIntoTaskDBSchemaField
	FinishedAt             ImportIntoTaskDBSchemaField
	CreatorID              ImportIntoTaskDBSchemaField
	Creator                ImportIntoTaskDBSchemaField
	TargetUsername         ImportIntoTaskDBSchemaField
	TargetPassword         ImportIntoTaskDBSchemaField
	CustomCSVFormat        ImportIntoTaskDBSchemaField
	Options                ImportIntoTaskDBSchemaField
	TotalSize              ImportIntoTaskDBSchemaField
	TotalFiles             ImportIntoTaskDBSchemaField
	SourceURI              ImportIntoTaskDBSchemaField
	ImportResults          ImportIntoTaskDBSchemaField
	ServerTier             ImportIntoTaskDBSchemaField
	ArchType               ImportIntoTaskDBSchemaField
	GroupKey               ImportIntoTaskDBSchemaField
	CustomStatusRegistered ImportIntoTaskDBSchemaField
	CustomStatusRetryAt    ImportIntoTaskDBSchemaField
}{

	ID:                     ImportIntoTaskDBSchemaField("id"),
	CreatedAt:              ImportIntoTaskDBSchemaField("created_at"),
	UpdatedAt:              ImportIntoTaskDBSchemaField("updated_at"),
	Versioning:             ImportIntoTaskDBSchemaField("versioning"),
	Name:                   ImportIntoTaskDBSchemaField("name"),
	ClusterID:              ImportIntoTaskDBSchemaField("cluster_id"),
	ProjectID:              ImportIntoTaskDBSchemaField("project_id"),
	TenantID:               ImportIntoTaskDBSchemaField("tenant_id"),
	Status:                 ImportIntoTaskDBSchemaField("status"),
	Message:                ImportIntoTaskDBSchemaField("message"),
	StartedAt:              ImportIntoTaskDBSchemaField("started_at"),
	FinishedAt:             ImportIntoTaskDBSchemaField("finished_at"),
	CreatorID:              ImportIntoTaskDBSchemaField("creator_id"),
	Creator:                ImportIntoTaskDBSchemaField("creator"),
	TargetUsername:         ImportIntoTaskDBSchemaField("target_username"),
	TargetPassword:         ImportIntoTaskDBSchemaField("target_password"),
	CustomCSVFormat:        ImportIntoTaskDBSchemaField("custom_csv_format"),
	Options:                ImportIntoTaskDBSchemaField("options"),
	TotalSize:              ImportIntoTaskDBSchemaField("total_size"),
	TotalFiles:             ImportIntoTaskDBSchemaField("total_files"),
	SourceURI:              ImportIntoTaskDBSchemaField("source_uri"),
	ImportResults:          ImportIntoTaskDBSchemaField("import_results"),
	ServerTier:             ImportIntoTaskDBSchemaField("server_tier"),
	ArchType:               ImportIntoTaskDBSchemaField("arch_type"),
	GroupKey:               ImportIntoTaskDBSchemaField("group_key"),
	CustomStatusRegistered: ImportIntoTaskDBSchemaField("custom_status_registered"),
	CustomStatusRetryAt:    ImportIntoTaskDBSchemaField("custom_status_retry_at"),
}

// Update updates ImportIntoTask fields by primary key
// nolint: dupl
func (o *ImportIntoTask) Update(db *gorm.DB, fields ...ImportIntoTaskDBSchemaField) error {
	dbNameToFieldName := map[string]interface{}{
		"id":                       o.ID,
		"created_at":               o.CreatedAt,
		"updated_at":               o.UpdatedAt,
		"versioning":               o.Versioning,
		"name":                     o.Name,
		"cluster_id":               o.ClusterID,
		"project_id":               o.ProjectID,
		"tenant_id":                o.TenantID,
		"status":                   o.Status,
		"message":                  o.Message,
		"started_at":               o.StartedAt,
		"finished_at":              o.FinishedAt,
		"creator_id":               o.CreatorID,
		"creator":                  o.Creator,
		"target_username":          o.TargetUsername,
		"target_password":          o.TargetPassword,
		"custom_csv_format":        o.CustomCSVFormat,
		"options":                  o.Options,
		"total_size":               o.TotalSize,
		"total_files":              o.TotalFiles,
		"source_uri":               o.SourceURI,
		"import_results":           o.ImportResults,
		"server_tier":              o.ServerTier,
		"arch_type":                o.ArchType,
		"group_key":                o.GroupKey,
		"custom_status_registered": o.CustomStatusRegistered,
		"custom_status_retry_at":   o.CustomStatusRetryAt,
	}
	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 ImportIntoTask %v fields %v: %s",
			o, fields, err)
	}

	return nil
}

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

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

// ===== END of ImportIntoTask modifiers

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