// Code generated by ent, DO NOT EDIT.

package item

import (
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"github.com/google/uuid"
	"github.com/hay-kot/homebox/backend/internal/data/ent/predicate"
)

// ID filters vertices based on their ID field.
func ID(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		v := make([]any, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		v := make([]any, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id uuid.UUID) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
func CreatedAt(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldCreatedAt), v))
	})
}

// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
func UpdatedAt(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUpdatedAt), v))
	})
}

// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
func Name(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldName), v))
	})
}

// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
func Description(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDescription), v))
	})
}

// ImportRef applies equality check predicate on the "import_ref" field. It's identical to ImportRefEQ.
func ImportRef(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImportRef), v))
	})
}

// Notes applies equality check predicate on the "notes" field. It's identical to NotesEQ.
func Notes(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldNotes), v))
	})
}

// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
func Quantity(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldQuantity), v))
	})
}

// Insured applies equality check predicate on the "insured" field. It's identical to InsuredEQ.
func Insured(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldInsured), v))
	})
}

// Archived applies equality check predicate on the "archived" field. It's identical to ArchivedEQ.
func Archived(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldArchived), v))
	})
}

// AssetID applies equality check predicate on the "asset_id" field. It's identical to AssetIDEQ.
func AssetID(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAssetID), v))
	})
}

// SerialNumber applies equality check predicate on the "serial_number" field. It's identical to SerialNumberEQ.
func SerialNumber(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSerialNumber), v))
	})
}

// ModelNumber applies equality check predicate on the "model_number" field. It's identical to ModelNumberEQ.
func ModelNumber(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldModelNumber), v))
	})
}

// Manufacturer applies equality check predicate on the "manufacturer" field. It's identical to ManufacturerEQ.
func Manufacturer(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldManufacturer), v))
	})
}

// LifetimeWarranty applies equality check predicate on the "lifetime_warranty" field. It's identical to LifetimeWarrantyEQ.
func LifetimeWarranty(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLifetimeWarranty), v))
	})
}

// WarrantyExpires applies equality check predicate on the "warranty_expires" field. It's identical to WarrantyExpiresEQ.
func WarrantyExpires(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyDetails applies equality check predicate on the "warranty_details" field. It's identical to WarrantyDetailsEQ.
func WarrantyDetails(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWarrantyDetails), v))
	})
}

// PurchaseTime applies equality check predicate on the "purchase_time" field. It's identical to PurchaseTimeEQ.
func PurchaseTime(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseFrom applies equality check predicate on the "purchase_from" field. It's identical to PurchaseFromEQ.
func PurchaseFrom(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchaseFrom), v))
	})
}

// PurchasePrice applies equality check predicate on the "purchase_price" field. It's identical to PurchasePriceEQ.
func PurchasePrice(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchasePrice), v))
	})
}

// SoldTime applies equality check predicate on the "sold_time" field. It's identical to SoldTimeEQ.
func SoldTime(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldTime), v))
	})
}

// SoldTo applies equality check predicate on the "sold_to" field. It's identical to SoldToEQ.
func SoldTo(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldTo), v))
	})
}

// SoldPrice applies equality check predicate on the "sold_price" field. It's identical to SoldPriceEQ.
func SoldPrice(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldPrice), v))
	})
}

// SoldNotes applies equality check predicate on the "sold_notes" field. It's identical to SoldNotesEQ.
func SoldNotes(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldNotes), v))
	})
}

// CreatedAtEQ applies the EQ predicate on the "created_at" field.
func CreatedAtEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldCreatedAt), v))
	})
}

// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
func CreatedAtNEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldCreatedAt), v))
	})
}

// CreatedAtIn applies the In predicate on the "created_at" field.
func CreatedAtIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldCreatedAt), v...))
	})
}

// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
func CreatedAtNotIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldCreatedAt), v...))
	})
}

// CreatedAtGT applies the GT predicate on the "created_at" field.
func CreatedAtGT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldCreatedAt), v))
	})
}

// CreatedAtGTE applies the GTE predicate on the "created_at" field.
func CreatedAtGTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldCreatedAt), v))
	})
}

// CreatedAtLT applies the LT predicate on the "created_at" field.
func CreatedAtLT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldCreatedAt), v))
	})
}

// CreatedAtLTE applies the LTE predicate on the "created_at" field.
func CreatedAtLTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldCreatedAt), v))
	})
}

// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
func UpdatedAtEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUpdatedAt), v))
	})
}

// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
func UpdatedAtNEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUpdatedAt), v))
	})
}

// UpdatedAtIn applies the In predicate on the "updated_at" field.
func UpdatedAtIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldUpdatedAt), v...))
	})
}

// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
func UpdatedAtNotIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldUpdatedAt), v...))
	})
}

// UpdatedAtGT applies the GT predicate on the "updated_at" field.
func UpdatedAtGT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUpdatedAt), v))
	})
}

// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
func UpdatedAtGTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUpdatedAt), v))
	})
}

// UpdatedAtLT applies the LT predicate on the "updated_at" field.
func UpdatedAtLT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUpdatedAt), v))
	})
}

// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
func UpdatedAtLTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUpdatedAt), v))
	})
}

// NameEQ applies the EQ predicate on the "name" field.
func NameEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldName), v))
	})
}

// NameNEQ applies the NEQ predicate on the "name" field.
func NameNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldName), v))
	})
}

// NameIn applies the In predicate on the "name" field.
func NameIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldName), v...))
	})
}

// NameNotIn applies the NotIn predicate on the "name" field.
func NameNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldName), v...))
	})
}

// NameGT applies the GT predicate on the "name" field.
func NameGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldName), v))
	})
}

// NameGTE applies the GTE predicate on the "name" field.
func NameGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldName), v))
	})
}

// NameLT applies the LT predicate on the "name" field.
func NameLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldName), v))
	})
}

// NameLTE applies the LTE predicate on the "name" field.
func NameLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldName), v))
	})
}

// NameContains applies the Contains predicate on the "name" field.
func NameContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldName), v))
	})
}

// NameHasPrefix applies the HasPrefix predicate on the "name" field.
func NameHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldName), v))
	})
}

// NameHasSuffix applies the HasSuffix predicate on the "name" field.
func NameHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldName), v))
	})
}

// NameEqualFold applies the EqualFold predicate on the "name" field.
func NameEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldName), v))
	})
}

// NameContainsFold applies the ContainsFold predicate on the "name" field.
func NameContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldName), v))
	})
}

// DescriptionEQ applies the EQ predicate on the "description" field.
func DescriptionEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldDescription), v))
	})
}

// DescriptionNEQ applies the NEQ predicate on the "description" field.
func DescriptionNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldDescription), v))
	})
}

// DescriptionIn applies the In predicate on the "description" field.
func DescriptionIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldDescription), v...))
	})
}

// DescriptionNotIn applies the NotIn predicate on the "description" field.
func DescriptionNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldDescription), v...))
	})
}

// DescriptionGT applies the GT predicate on the "description" field.
func DescriptionGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldDescription), v))
	})
}

// DescriptionGTE applies the GTE predicate on the "description" field.
func DescriptionGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldDescription), v))
	})
}

// DescriptionLT applies the LT predicate on the "description" field.
func DescriptionLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldDescription), v))
	})
}

// DescriptionLTE applies the LTE predicate on the "description" field.
func DescriptionLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldDescription), v))
	})
}

// DescriptionContains applies the Contains predicate on the "description" field.
func DescriptionContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldDescription), v))
	})
}

// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
func DescriptionHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldDescription), v))
	})
}

// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
func DescriptionHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldDescription), v))
	})
}

// DescriptionIsNil applies the IsNil predicate on the "description" field.
func DescriptionIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldDescription)))
	})
}

// DescriptionNotNil applies the NotNil predicate on the "description" field.
func DescriptionNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldDescription)))
	})
}

// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
func DescriptionEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldDescription), v))
	})
}

// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
func DescriptionContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldDescription), v))
	})
}

// ImportRefEQ applies the EQ predicate on the "import_ref" field.
func ImportRefEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImportRef), v))
	})
}

// ImportRefNEQ applies the NEQ predicate on the "import_ref" field.
func ImportRefNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldImportRef), v))
	})
}

// ImportRefIn applies the In predicate on the "import_ref" field.
func ImportRefIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldImportRef), v...))
	})
}

// ImportRefNotIn applies the NotIn predicate on the "import_ref" field.
func ImportRefNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldImportRef), v...))
	})
}

// ImportRefGT applies the GT predicate on the "import_ref" field.
func ImportRefGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldImportRef), v))
	})
}

// ImportRefGTE applies the GTE predicate on the "import_ref" field.
func ImportRefGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldImportRef), v))
	})
}

// ImportRefLT applies the LT predicate on the "import_ref" field.
func ImportRefLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldImportRef), v))
	})
}

// ImportRefLTE applies the LTE predicate on the "import_ref" field.
func ImportRefLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldImportRef), v))
	})
}

// ImportRefContains applies the Contains predicate on the "import_ref" field.
func ImportRefContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldImportRef), v))
	})
}

// ImportRefHasPrefix applies the HasPrefix predicate on the "import_ref" field.
func ImportRefHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldImportRef), v))
	})
}

// ImportRefHasSuffix applies the HasSuffix predicate on the "import_ref" field.
func ImportRefHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldImportRef), v))
	})
}

// ImportRefIsNil applies the IsNil predicate on the "import_ref" field.
func ImportRefIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldImportRef)))
	})
}

// ImportRefNotNil applies the NotNil predicate on the "import_ref" field.
func ImportRefNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldImportRef)))
	})
}

// ImportRefEqualFold applies the EqualFold predicate on the "import_ref" field.
func ImportRefEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldImportRef), v))
	})
}

// ImportRefContainsFold applies the ContainsFold predicate on the "import_ref" field.
func ImportRefContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldImportRef), v))
	})
}

// NotesEQ applies the EQ predicate on the "notes" field.
func NotesEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldNotes), v))
	})
}

// NotesNEQ applies the NEQ predicate on the "notes" field.
func NotesNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldNotes), v))
	})
}

// NotesIn applies the In predicate on the "notes" field.
func NotesIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldNotes), v...))
	})
}

// NotesNotIn applies the NotIn predicate on the "notes" field.
func NotesNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldNotes), v...))
	})
}

// NotesGT applies the GT predicate on the "notes" field.
func NotesGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldNotes), v))
	})
}

// NotesGTE applies the GTE predicate on the "notes" field.
func NotesGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldNotes), v))
	})
}

// NotesLT applies the LT predicate on the "notes" field.
func NotesLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldNotes), v))
	})
}

// NotesLTE applies the LTE predicate on the "notes" field.
func NotesLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldNotes), v))
	})
}

// NotesContains applies the Contains predicate on the "notes" field.
func NotesContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldNotes), v))
	})
}

// NotesHasPrefix applies the HasPrefix predicate on the "notes" field.
func NotesHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldNotes), v))
	})
}

// NotesHasSuffix applies the HasSuffix predicate on the "notes" field.
func NotesHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldNotes), v))
	})
}

// NotesIsNil applies the IsNil predicate on the "notes" field.
func NotesIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldNotes)))
	})
}

// NotesNotNil applies the NotNil predicate on the "notes" field.
func NotesNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldNotes)))
	})
}

// NotesEqualFold applies the EqualFold predicate on the "notes" field.
func NotesEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldNotes), v))
	})
}

// NotesContainsFold applies the ContainsFold predicate on the "notes" field.
func NotesContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldNotes), v))
	})
}

// QuantityEQ applies the EQ predicate on the "quantity" field.
func QuantityEQ(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldQuantity), v))
	})
}

// QuantityNEQ applies the NEQ predicate on the "quantity" field.
func QuantityNEQ(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldQuantity), v))
	})
}

// QuantityIn applies the In predicate on the "quantity" field.
func QuantityIn(vs ...int) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldQuantity), v...))
	})
}

// QuantityNotIn applies the NotIn predicate on the "quantity" field.
func QuantityNotIn(vs ...int) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldQuantity), v...))
	})
}

// QuantityGT applies the GT predicate on the "quantity" field.
func QuantityGT(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldQuantity), v))
	})
}

// QuantityGTE applies the GTE predicate on the "quantity" field.
func QuantityGTE(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldQuantity), v))
	})
}

// QuantityLT applies the LT predicate on the "quantity" field.
func QuantityLT(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldQuantity), v))
	})
}

// QuantityLTE applies the LTE predicate on the "quantity" field.
func QuantityLTE(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldQuantity), v))
	})
}

// InsuredEQ applies the EQ predicate on the "insured" field.
func InsuredEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldInsured), v))
	})
}

// InsuredNEQ applies the NEQ predicate on the "insured" field.
func InsuredNEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldInsured), v))
	})
}

// ArchivedEQ applies the EQ predicate on the "archived" field.
func ArchivedEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldArchived), v))
	})
}

// ArchivedNEQ applies the NEQ predicate on the "archived" field.
func ArchivedNEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldArchived), v))
	})
}

// AssetIDEQ applies the EQ predicate on the "asset_id" field.
func AssetIDEQ(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAssetID), v))
	})
}

// AssetIDNEQ applies the NEQ predicate on the "asset_id" field.
func AssetIDNEQ(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAssetID), v))
	})
}

// AssetIDIn applies the In predicate on the "asset_id" field.
func AssetIDIn(vs ...int) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldAssetID), v...))
	})
}

// AssetIDNotIn applies the NotIn predicate on the "asset_id" field.
func AssetIDNotIn(vs ...int) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldAssetID), v...))
	})
}

// AssetIDGT applies the GT predicate on the "asset_id" field.
func AssetIDGT(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAssetID), v))
	})
}

// AssetIDGTE applies the GTE predicate on the "asset_id" field.
func AssetIDGTE(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAssetID), v))
	})
}

// AssetIDLT applies the LT predicate on the "asset_id" field.
func AssetIDLT(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAssetID), v))
	})
}

// AssetIDLTE applies the LTE predicate on the "asset_id" field.
func AssetIDLTE(v int) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAssetID), v))
	})
}

// SerialNumberEQ applies the EQ predicate on the "serial_number" field.
func SerialNumberEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberNEQ applies the NEQ predicate on the "serial_number" field.
func SerialNumberNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberIn applies the In predicate on the "serial_number" field.
func SerialNumberIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSerialNumber), v...))
	})
}

// SerialNumberNotIn applies the NotIn predicate on the "serial_number" field.
func SerialNumberNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSerialNumber), v...))
	})
}

// SerialNumberGT applies the GT predicate on the "serial_number" field.
func SerialNumberGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberGTE applies the GTE predicate on the "serial_number" field.
func SerialNumberGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberLT applies the LT predicate on the "serial_number" field.
func SerialNumberLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberLTE applies the LTE predicate on the "serial_number" field.
func SerialNumberLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberContains applies the Contains predicate on the "serial_number" field.
func SerialNumberContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberHasPrefix applies the HasPrefix predicate on the "serial_number" field.
func SerialNumberHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberHasSuffix applies the HasSuffix predicate on the "serial_number" field.
func SerialNumberHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberIsNil applies the IsNil predicate on the "serial_number" field.
func SerialNumberIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldSerialNumber)))
	})
}

// SerialNumberNotNil applies the NotNil predicate on the "serial_number" field.
func SerialNumberNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldSerialNumber)))
	})
}

// SerialNumberEqualFold applies the EqualFold predicate on the "serial_number" field.
func SerialNumberEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldSerialNumber), v))
	})
}

// SerialNumberContainsFold applies the ContainsFold predicate on the "serial_number" field.
func SerialNumberContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldSerialNumber), v))
	})
}

// ModelNumberEQ applies the EQ predicate on the "model_number" field.
func ModelNumberEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldModelNumber), v))
	})
}

// ModelNumberNEQ applies the NEQ predicate on the "model_number" field.
func ModelNumberNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldModelNumber), v))
	})
}

// ModelNumberIn applies the In predicate on the "model_number" field.
func ModelNumberIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldModelNumber), v...))
	})
}

// ModelNumberNotIn applies the NotIn predicate on the "model_number" field.
func ModelNumberNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldModelNumber), v...))
	})
}

// ModelNumberGT applies the GT predicate on the "model_number" field.
func ModelNumberGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldModelNumber), v))
	})
}

// ModelNumberGTE applies the GTE predicate on the "model_number" field.
func ModelNumberGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldModelNumber), v))
	})
}

// ModelNumberLT applies the LT predicate on the "model_number" field.
func ModelNumberLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldModelNumber), v))
	})
}

// ModelNumberLTE applies the LTE predicate on the "model_number" field.
func ModelNumberLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldModelNumber), v))
	})
}

// ModelNumberContains applies the Contains predicate on the "model_number" field.
func ModelNumberContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldModelNumber), v))
	})
}

// ModelNumberHasPrefix applies the HasPrefix predicate on the "model_number" field.
func ModelNumberHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldModelNumber), v))
	})
}

// ModelNumberHasSuffix applies the HasSuffix predicate on the "model_number" field.
func ModelNumberHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldModelNumber), v))
	})
}

// ModelNumberIsNil applies the IsNil predicate on the "model_number" field.
func ModelNumberIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldModelNumber)))
	})
}

// ModelNumberNotNil applies the NotNil predicate on the "model_number" field.
func ModelNumberNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldModelNumber)))
	})
}

// ModelNumberEqualFold applies the EqualFold predicate on the "model_number" field.
func ModelNumberEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldModelNumber), v))
	})
}

// ModelNumberContainsFold applies the ContainsFold predicate on the "model_number" field.
func ModelNumberContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldModelNumber), v))
	})
}

// ManufacturerEQ applies the EQ predicate on the "manufacturer" field.
func ManufacturerEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldManufacturer), v))
	})
}

// ManufacturerNEQ applies the NEQ predicate on the "manufacturer" field.
func ManufacturerNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldManufacturer), v))
	})
}

// ManufacturerIn applies the In predicate on the "manufacturer" field.
func ManufacturerIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldManufacturer), v...))
	})
}

// ManufacturerNotIn applies the NotIn predicate on the "manufacturer" field.
func ManufacturerNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldManufacturer), v...))
	})
}

// ManufacturerGT applies the GT predicate on the "manufacturer" field.
func ManufacturerGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldManufacturer), v))
	})
}

// ManufacturerGTE applies the GTE predicate on the "manufacturer" field.
func ManufacturerGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldManufacturer), v))
	})
}

// ManufacturerLT applies the LT predicate on the "manufacturer" field.
func ManufacturerLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldManufacturer), v))
	})
}

// ManufacturerLTE applies the LTE predicate on the "manufacturer" field.
func ManufacturerLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldManufacturer), v))
	})
}

// ManufacturerContains applies the Contains predicate on the "manufacturer" field.
func ManufacturerContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldManufacturer), v))
	})
}

// ManufacturerHasPrefix applies the HasPrefix predicate on the "manufacturer" field.
func ManufacturerHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldManufacturer), v))
	})
}

// ManufacturerHasSuffix applies the HasSuffix predicate on the "manufacturer" field.
func ManufacturerHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldManufacturer), v))
	})
}

// ManufacturerIsNil applies the IsNil predicate on the "manufacturer" field.
func ManufacturerIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldManufacturer)))
	})
}

// ManufacturerNotNil applies the NotNil predicate on the "manufacturer" field.
func ManufacturerNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldManufacturer)))
	})
}

// ManufacturerEqualFold applies the EqualFold predicate on the "manufacturer" field.
func ManufacturerEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldManufacturer), v))
	})
}

// ManufacturerContainsFold applies the ContainsFold predicate on the "manufacturer" field.
func ManufacturerContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldManufacturer), v))
	})
}

// LifetimeWarrantyEQ applies the EQ predicate on the "lifetime_warranty" field.
func LifetimeWarrantyEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLifetimeWarranty), v))
	})
}

// LifetimeWarrantyNEQ applies the NEQ predicate on the "lifetime_warranty" field.
func LifetimeWarrantyNEQ(v bool) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldLifetimeWarranty), v))
	})
}

// WarrantyExpiresEQ applies the EQ predicate on the "warranty_expires" field.
func WarrantyExpiresEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresNEQ applies the NEQ predicate on the "warranty_expires" field.
func WarrantyExpiresNEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresIn applies the In predicate on the "warranty_expires" field.
func WarrantyExpiresIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldWarrantyExpires), v...))
	})
}

// WarrantyExpiresNotIn applies the NotIn predicate on the "warranty_expires" field.
func WarrantyExpiresNotIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldWarrantyExpires), v...))
	})
}

// WarrantyExpiresGT applies the GT predicate on the "warranty_expires" field.
func WarrantyExpiresGT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresGTE applies the GTE predicate on the "warranty_expires" field.
func WarrantyExpiresGTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresLT applies the LT predicate on the "warranty_expires" field.
func WarrantyExpiresLT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresLTE applies the LTE predicate on the "warranty_expires" field.
func WarrantyExpiresLTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldWarrantyExpires), v))
	})
}

// WarrantyExpiresIsNil applies the IsNil predicate on the "warranty_expires" field.
func WarrantyExpiresIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldWarrantyExpires)))
	})
}

// WarrantyExpiresNotNil applies the NotNil predicate on the "warranty_expires" field.
func WarrantyExpiresNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldWarrantyExpires)))
	})
}

// WarrantyDetailsEQ applies the EQ predicate on the "warranty_details" field.
func WarrantyDetailsEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsNEQ applies the NEQ predicate on the "warranty_details" field.
func WarrantyDetailsNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsIn applies the In predicate on the "warranty_details" field.
func WarrantyDetailsIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldWarrantyDetails), v...))
	})
}

// WarrantyDetailsNotIn applies the NotIn predicate on the "warranty_details" field.
func WarrantyDetailsNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldWarrantyDetails), v...))
	})
}

// WarrantyDetailsGT applies the GT predicate on the "warranty_details" field.
func WarrantyDetailsGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsGTE applies the GTE predicate on the "warranty_details" field.
func WarrantyDetailsGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsLT applies the LT predicate on the "warranty_details" field.
func WarrantyDetailsLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsLTE applies the LTE predicate on the "warranty_details" field.
func WarrantyDetailsLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsContains applies the Contains predicate on the "warranty_details" field.
func WarrantyDetailsContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsHasPrefix applies the HasPrefix predicate on the "warranty_details" field.
func WarrantyDetailsHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsHasSuffix applies the HasSuffix predicate on the "warranty_details" field.
func WarrantyDetailsHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsIsNil applies the IsNil predicate on the "warranty_details" field.
func WarrantyDetailsIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldWarrantyDetails)))
	})
}

// WarrantyDetailsNotNil applies the NotNil predicate on the "warranty_details" field.
func WarrantyDetailsNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldWarrantyDetails)))
	})
}

// WarrantyDetailsEqualFold applies the EqualFold predicate on the "warranty_details" field.
func WarrantyDetailsEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldWarrantyDetails), v))
	})
}

// WarrantyDetailsContainsFold applies the ContainsFold predicate on the "warranty_details" field.
func WarrantyDetailsContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldWarrantyDetails), v))
	})
}

// PurchaseTimeEQ applies the EQ predicate on the "purchase_time" field.
func PurchaseTimeEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeNEQ applies the NEQ predicate on the "purchase_time" field.
func PurchaseTimeNEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeIn applies the In predicate on the "purchase_time" field.
func PurchaseTimeIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldPurchaseTime), v...))
	})
}

// PurchaseTimeNotIn applies the NotIn predicate on the "purchase_time" field.
func PurchaseTimeNotIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldPurchaseTime), v...))
	})
}

// PurchaseTimeGT applies the GT predicate on the "purchase_time" field.
func PurchaseTimeGT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeGTE applies the GTE predicate on the "purchase_time" field.
func PurchaseTimeGTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeLT applies the LT predicate on the "purchase_time" field.
func PurchaseTimeLT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeLTE applies the LTE predicate on the "purchase_time" field.
func PurchaseTimeLTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldPurchaseTime), v))
	})
}

// PurchaseTimeIsNil applies the IsNil predicate on the "purchase_time" field.
func PurchaseTimeIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldPurchaseTime)))
	})
}

// PurchaseTimeNotNil applies the NotNil predicate on the "purchase_time" field.
func PurchaseTimeNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldPurchaseTime)))
	})
}

// PurchaseFromEQ applies the EQ predicate on the "purchase_from" field.
func PurchaseFromEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromNEQ applies the NEQ predicate on the "purchase_from" field.
func PurchaseFromNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromIn applies the In predicate on the "purchase_from" field.
func PurchaseFromIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldPurchaseFrom), v...))
	})
}

// PurchaseFromNotIn applies the NotIn predicate on the "purchase_from" field.
func PurchaseFromNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldPurchaseFrom), v...))
	})
}

// PurchaseFromGT applies the GT predicate on the "purchase_from" field.
func PurchaseFromGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromGTE applies the GTE predicate on the "purchase_from" field.
func PurchaseFromGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromLT applies the LT predicate on the "purchase_from" field.
func PurchaseFromLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromLTE applies the LTE predicate on the "purchase_from" field.
func PurchaseFromLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromContains applies the Contains predicate on the "purchase_from" field.
func PurchaseFromContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromHasPrefix applies the HasPrefix predicate on the "purchase_from" field.
func PurchaseFromHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromHasSuffix applies the HasSuffix predicate on the "purchase_from" field.
func PurchaseFromHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromIsNil applies the IsNil predicate on the "purchase_from" field.
func PurchaseFromIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldPurchaseFrom)))
	})
}

// PurchaseFromNotNil applies the NotNil predicate on the "purchase_from" field.
func PurchaseFromNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldPurchaseFrom)))
	})
}

// PurchaseFromEqualFold applies the EqualFold predicate on the "purchase_from" field.
func PurchaseFromEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldPurchaseFrom), v))
	})
}

// PurchaseFromContainsFold applies the ContainsFold predicate on the "purchase_from" field.
func PurchaseFromContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldPurchaseFrom), v))
	})
}

// PurchasePriceEQ applies the EQ predicate on the "purchase_price" field.
func PurchasePriceEQ(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPurchasePrice), v))
	})
}

// PurchasePriceNEQ applies the NEQ predicate on the "purchase_price" field.
func PurchasePriceNEQ(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPurchasePrice), v))
	})
}

// PurchasePriceIn applies the In predicate on the "purchase_price" field.
func PurchasePriceIn(vs ...float64) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldPurchasePrice), v...))
	})
}

// PurchasePriceNotIn applies the NotIn predicate on the "purchase_price" field.
func PurchasePriceNotIn(vs ...float64) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldPurchasePrice), v...))
	})
}

// PurchasePriceGT applies the GT predicate on the "purchase_price" field.
func PurchasePriceGT(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldPurchasePrice), v))
	})
}

// PurchasePriceGTE applies the GTE predicate on the "purchase_price" field.
func PurchasePriceGTE(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldPurchasePrice), v))
	})
}

// PurchasePriceLT applies the LT predicate on the "purchase_price" field.
func PurchasePriceLT(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldPurchasePrice), v))
	})
}

// PurchasePriceLTE applies the LTE predicate on the "purchase_price" field.
func PurchasePriceLTE(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldPurchasePrice), v))
	})
}

// SoldTimeEQ applies the EQ predicate on the "sold_time" field.
func SoldTimeEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldTime), v))
	})
}

// SoldTimeNEQ applies the NEQ predicate on the "sold_time" field.
func SoldTimeNEQ(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSoldTime), v))
	})
}

// SoldTimeIn applies the In predicate on the "sold_time" field.
func SoldTimeIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSoldTime), v...))
	})
}

// SoldTimeNotIn applies the NotIn predicate on the "sold_time" field.
func SoldTimeNotIn(vs ...time.Time) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSoldTime), v...))
	})
}

// SoldTimeGT applies the GT predicate on the "sold_time" field.
func SoldTimeGT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSoldTime), v))
	})
}

// SoldTimeGTE applies the GTE predicate on the "sold_time" field.
func SoldTimeGTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSoldTime), v))
	})
}

// SoldTimeLT applies the LT predicate on the "sold_time" field.
func SoldTimeLT(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSoldTime), v))
	})
}

// SoldTimeLTE applies the LTE predicate on the "sold_time" field.
func SoldTimeLTE(v time.Time) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSoldTime), v))
	})
}

// SoldTimeIsNil applies the IsNil predicate on the "sold_time" field.
func SoldTimeIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldSoldTime)))
	})
}

// SoldTimeNotNil applies the NotNil predicate on the "sold_time" field.
func SoldTimeNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldSoldTime)))
	})
}

// SoldToEQ applies the EQ predicate on the "sold_to" field.
func SoldToEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldTo), v))
	})
}

// SoldToNEQ applies the NEQ predicate on the "sold_to" field.
func SoldToNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSoldTo), v))
	})
}

// SoldToIn applies the In predicate on the "sold_to" field.
func SoldToIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSoldTo), v...))
	})
}

// SoldToNotIn applies the NotIn predicate on the "sold_to" field.
func SoldToNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSoldTo), v...))
	})
}

// SoldToGT applies the GT predicate on the "sold_to" field.
func SoldToGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSoldTo), v))
	})
}

// SoldToGTE applies the GTE predicate on the "sold_to" field.
func SoldToGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSoldTo), v))
	})
}

// SoldToLT applies the LT predicate on the "sold_to" field.
func SoldToLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSoldTo), v))
	})
}

// SoldToLTE applies the LTE predicate on the "sold_to" field.
func SoldToLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSoldTo), v))
	})
}

// SoldToContains applies the Contains predicate on the "sold_to" field.
func SoldToContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldSoldTo), v))
	})
}

// SoldToHasPrefix applies the HasPrefix predicate on the "sold_to" field.
func SoldToHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldSoldTo), v))
	})
}

// SoldToHasSuffix applies the HasSuffix predicate on the "sold_to" field.
func SoldToHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldSoldTo), v))
	})
}

// SoldToIsNil applies the IsNil predicate on the "sold_to" field.
func SoldToIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldSoldTo)))
	})
}

// SoldToNotNil applies the NotNil predicate on the "sold_to" field.
func SoldToNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldSoldTo)))
	})
}

// SoldToEqualFold applies the EqualFold predicate on the "sold_to" field.
func SoldToEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldSoldTo), v))
	})
}

// SoldToContainsFold applies the ContainsFold predicate on the "sold_to" field.
func SoldToContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldSoldTo), v))
	})
}

// SoldPriceEQ applies the EQ predicate on the "sold_price" field.
func SoldPriceEQ(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldPrice), v))
	})
}

// SoldPriceNEQ applies the NEQ predicate on the "sold_price" field.
func SoldPriceNEQ(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSoldPrice), v))
	})
}

// SoldPriceIn applies the In predicate on the "sold_price" field.
func SoldPriceIn(vs ...float64) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSoldPrice), v...))
	})
}

// SoldPriceNotIn applies the NotIn predicate on the "sold_price" field.
func SoldPriceNotIn(vs ...float64) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSoldPrice), v...))
	})
}

// SoldPriceGT applies the GT predicate on the "sold_price" field.
func SoldPriceGT(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSoldPrice), v))
	})
}

// SoldPriceGTE applies the GTE predicate on the "sold_price" field.
func SoldPriceGTE(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSoldPrice), v))
	})
}

// SoldPriceLT applies the LT predicate on the "sold_price" field.
func SoldPriceLT(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSoldPrice), v))
	})
}

// SoldPriceLTE applies the LTE predicate on the "sold_price" field.
func SoldPriceLTE(v float64) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSoldPrice), v))
	})
}

// SoldNotesEQ applies the EQ predicate on the "sold_notes" field.
func SoldNotesEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesNEQ applies the NEQ predicate on the "sold_notes" field.
func SoldNotesNEQ(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesIn applies the In predicate on the "sold_notes" field.
func SoldNotesIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSoldNotes), v...))
	})
}

// SoldNotesNotIn applies the NotIn predicate on the "sold_notes" field.
func SoldNotesNotIn(vs ...string) predicate.Item {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSoldNotes), v...))
	})
}

// SoldNotesGT applies the GT predicate on the "sold_notes" field.
func SoldNotesGT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesGTE applies the GTE predicate on the "sold_notes" field.
func SoldNotesGTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesLT applies the LT predicate on the "sold_notes" field.
func SoldNotesLT(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesLTE applies the LTE predicate on the "sold_notes" field.
func SoldNotesLTE(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesContains applies the Contains predicate on the "sold_notes" field.
func SoldNotesContains(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesHasPrefix applies the HasPrefix predicate on the "sold_notes" field.
func SoldNotesHasPrefix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesHasSuffix applies the HasSuffix predicate on the "sold_notes" field.
func SoldNotesHasSuffix(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesIsNil applies the IsNil predicate on the "sold_notes" field.
func SoldNotesIsNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldSoldNotes)))
	})
}

// SoldNotesNotNil applies the NotNil predicate on the "sold_notes" field.
func SoldNotesNotNil() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldSoldNotes)))
	})
}

// SoldNotesEqualFold applies the EqualFold predicate on the "sold_notes" field.
func SoldNotesEqualFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldSoldNotes), v))
	})
}

// SoldNotesContainsFold applies the ContainsFold predicate on the "sold_notes" field.
func SoldNotesContainsFold(v string) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldSoldNotes), v))
	})
}

// HasParent applies the HasEdge predicate on the "parent" edge.
func HasParent() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(ParentTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasParentWith applies the HasEdge predicate on the "parent" edge with a given conditions (other predicates).
func HasParentWith(preds ...predicate.Item) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(Table, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasChildren applies the HasEdge predicate on the "children" edge.
func HasChildren() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(ChildrenTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasChildrenWith applies the HasEdge predicate on the "children" edge with a given conditions (other predicates).
func HasChildrenWith(preds ...predicate.Item) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(Table, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasGroup applies the HasEdge predicate on the "group" edge.
func HasGroup() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(GroupTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
func HasGroupWith(preds ...predicate.Group) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(GroupInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasLabel applies the HasEdge predicate on the "label" edge.
func HasLabel() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(LabelTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, LabelTable, LabelPrimaryKey...),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasLabelWith applies the HasEdge predicate on the "label" edge with a given conditions (other predicates).
func HasLabelWith(preds ...predicate.Label) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(LabelInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, LabelTable, LabelPrimaryKey...),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasLocation applies the HasEdge predicate on the "location" edge.
func HasLocation() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(LocationTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, LocationTable, LocationColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasLocationWith applies the HasEdge predicate on the "location" edge with a given conditions (other predicates).
func HasLocationWith(preds ...predicate.Location) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(LocationInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, LocationTable, LocationColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasFields applies the HasEdge predicate on the "fields" edge.
func HasFields() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(FieldsTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, FieldsTable, FieldsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasFieldsWith applies the HasEdge predicate on the "fields" edge with a given conditions (other predicates).
func HasFieldsWith(preds ...predicate.ItemField) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(FieldsInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, FieldsTable, FieldsColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasMaintenanceEntries applies the HasEdge predicate on the "maintenance_entries" edge.
func HasMaintenanceEntries() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MaintenanceEntriesTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, MaintenanceEntriesTable, MaintenanceEntriesColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasMaintenanceEntriesWith applies the HasEdge predicate on the "maintenance_entries" edge with a given conditions (other predicates).
func HasMaintenanceEntriesWith(preds ...predicate.MaintenanceEntry) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MaintenanceEntriesInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, MaintenanceEntriesTable, MaintenanceEntriesColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasAttachments applies the HasEdge predicate on the "attachments" edge.
func HasAttachments() predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(AttachmentsTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasAttachmentsWith applies the HasEdge predicate on the "attachments" edge with a given conditions (other predicates).
func HasAttachmentsWith(preds ...predicate.Attachment) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(AttachmentsInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Item) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Item) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Not applies the not operator on the given predicate.
func Not(p predicate.Item) predicate.Item {
	return predicate.Item(func(s *sql.Selector) {
		p(s.Not())
	})
}