registry-backend/ent/comfynode/where.go

// Code generated by ent, DO NOT EDIT.

package comfynode

import (
	"registry-backend/ent/predicate"
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"github.com/google/uuid"
)

// ID filters vertices based on their ID field.
func ID(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldID, id))
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldID, id))
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldID, id))
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldID, ids...))
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldID, ids...))
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldID, id))
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldID, id))
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldID, id))
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldID, id))
}

// CreateTime applies equality check predicate on the "create_time" field. It's identical to CreateTimeEQ.
func CreateTime(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldCreateTime, v))
}

// UpdateTime applies equality check predicate on the "update_time" field. It's identical to UpdateTimeEQ.
func UpdateTime(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldUpdateTime, v))
}

// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
func Name(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldName, v))
}

// NodeVersionID applies equality check predicate on the "node_version_id" field. It's identical to NodeVersionIDEQ.
func NodeVersionID(v uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldNodeVersionID, v))
}

// Category applies equality check predicate on the "category" field. It's identical to CategoryEQ.
func Category(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldCategory, v))
}

// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
func Description(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldDescription, v))
}

// InputTypes applies equality check predicate on the "input_types" field. It's identical to InputTypesEQ.
func InputTypes(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldInputTypes, v))
}

// Deprecated applies equality check predicate on the "deprecated" field. It's identical to DeprecatedEQ.
func Deprecated(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldDeprecated, v))
}

// Experimental applies equality check predicate on the "experimental" field. It's identical to ExperimentalEQ.
func Experimental(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldExperimental, v))
}

// ReturnNames applies equality check predicate on the "return_names" field. It's identical to ReturnNamesEQ.
func ReturnNames(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldReturnNames, v))
}

// ReturnTypes applies equality check predicate on the "return_types" field. It's identical to ReturnTypesEQ.
func ReturnTypes(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldReturnTypes, v))
}

// Function applies equality check predicate on the "function" field. It's identical to FunctionEQ.
func Function(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldFunction, v))
}

// CreateTimeEQ applies the EQ predicate on the "create_time" field.
func CreateTimeEQ(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldCreateTime, v))
}

// CreateTimeNEQ applies the NEQ predicate on the "create_time" field.
func CreateTimeNEQ(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldCreateTime, v))
}

// CreateTimeIn applies the In predicate on the "create_time" field.
func CreateTimeIn(vs ...time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldCreateTime, vs...))
}

// CreateTimeNotIn applies the NotIn predicate on the "create_time" field.
func CreateTimeNotIn(vs ...time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldCreateTime, vs...))
}

// CreateTimeGT applies the GT predicate on the "create_time" field.
func CreateTimeGT(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldCreateTime, v))
}

// CreateTimeGTE applies the GTE predicate on the "create_time" field.
func CreateTimeGTE(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldCreateTime, v))
}

// CreateTimeLT applies the LT predicate on the "create_time" field.
func CreateTimeLT(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldCreateTime, v))
}

// CreateTimeLTE applies the LTE predicate on the "create_time" field.
func CreateTimeLTE(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldCreateTime, v))
}

// UpdateTimeEQ applies the EQ predicate on the "update_time" field.
func UpdateTimeEQ(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldUpdateTime, v))
}

// UpdateTimeNEQ applies the NEQ predicate on the "update_time" field.
func UpdateTimeNEQ(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldUpdateTime, v))
}

// UpdateTimeIn applies the In predicate on the "update_time" field.
func UpdateTimeIn(vs ...time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldUpdateTime, vs...))
}

// UpdateTimeNotIn applies the NotIn predicate on the "update_time" field.
func UpdateTimeNotIn(vs ...time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldUpdateTime, vs...))
}

// UpdateTimeGT applies the GT predicate on the "update_time" field.
func UpdateTimeGT(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldUpdateTime, v))
}

// UpdateTimeGTE applies the GTE predicate on the "update_time" field.
func UpdateTimeGTE(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldUpdateTime, v))
}

// UpdateTimeLT applies the LT predicate on the "update_time" field.
func UpdateTimeLT(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldUpdateTime, v))
}

// UpdateTimeLTE applies the LTE predicate on the "update_time" field.
func UpdateTimeLTE(v time.Time) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldUpdateTime, v))
}

// NameEQ applies the EQ predicate on the "name" field.
func NameEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldName, v))
}

// NameNEQ applies the NEQ predicate on the "name" field.
func NameNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldName, v))
}

// NameIn applies the In predicate on the "name" field.
func NameIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldName, vs...))
}

// NameNotIn applies the NotIn predicate on the "name" field.
func NameNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldName, vs...))
}

// NameGT applies the GT predicate on the "name" field.
func NameGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldName, v))
}

// NameGTE applies the GTE predicate on the "name" field.
func NameGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldName, v))
}

// NameLT applies the LT predicate on the "name" field.
func NameLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldName, v))
}

// NameLTE applies the LTE predicate on the "name" field.
func NameLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldName, v))
}

// NameContains applies the Contains predicate on the "name" field.
func NameContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldName, v))
}

// NameHasPrefix applies the HasPrefix predicate on the "name" field.
func NameHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldName, v))
}

// NameHasSuffix applies the HasSuffix predicate on the "name" field.
func NameHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldName, v))
}

// NameEqualFold applies the EqualFold predicate on the "name" field.
func NameEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldName, v))
}

// NameContainsFold applies the ContainsFold predicate on the "name" field.
func NameContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldName, v))
}

// NodeVersionIDEQ applies the EQ predicate on the "node_version_id" field.
func NodeVersionIDEQ(v uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldNodeVersionID, v))
}

// NodeVersionIDNEQ applies the NEQ predicate on the "node_version_id" field.
func NodeVersionIDNEQ(v uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldNodeVersionID, v))
}

// NodeVersionIDIn applies the In predicate on the "node_version_id" field.
func NodeVersionIDIn(vs ...uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldNodeVersionID, vs...))
}

// NodeVersionIDNotIn applies the NotIn predicate on the "node_version_id" field.
func NodeVersionIDNotIn(vs ...uuid.UUID) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldNodeVersionID, vs...))
}

// CategoryEQ applies the EQ predicate on the "category" field.
func CategoryEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldCategory, v))
}

// CategoryNEQ applies the NEQ predicate on the "category" field.
func CategoryNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldCategory, v))
}

// CategoryIn applies the In predicate on the "category" field.
func CategoryIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldCategory, vs...))
}

// CategoryNotIn applies the NotIn predicate on the "category" field.
func CategoryNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldCategory, vs...))
}

// CategoryGT applies the GT predicate on the "category" field.
func CategoryGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldCategory, v))
}

// CategoryGTE applies the GTE predicate on the "category" field.
func CategoryGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldCategory, v))
}

// CategoryLT applies the LT predicate on the "category" field.
func CategoryLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldCategory, v))
}

// CategoryLTE applies the LTE predicate on the "category" field.
func CategoryLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldCategory, v))
}

// CategoryContains applies the Contains predicate on the "category" field.
func CategoryContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldCategory, v))
}

// CategoryHasPrefix applies the HasPrefix predicate on the "category" field.
func CategoryHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldCategory, v))
}

// CategoryHasSuffix applies the HasSuffix predicate on the "category" field.
func CategoryHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldCategory, v))
}

// CategoryIsNil applies the IsNil predicate on the "category" field.
func CategoryIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldCategory))
}

// CategoryNotNil applies the NotNil predicate on the "category" field.
func CategoryNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldCategory))
}

// CategoryEqualFold applies the EqualFold predicate on the "category" field.
func CategoryEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldCategory, v))
}

// CategoryContainsFold applies the ContainsFold predicate on the "category" field.
func CategoryContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldCategory, v))
}

// DescriptionEQ applies the EQ predicate on the "description" field.
func DescriptionEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldDescription, v))
}

// DescriptionNEQ applies the NEQ predicate on the "description" field.
func DescriptionNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldDescription, v))
}

// DescriptionIn applies the In predicate on the "description" field.
func DescriptionIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldDescription, vs...))
}

// DescriptionNotIn applies the NotIn predicate on the "description" field.
func DescriptionNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldDescription, vs...))
}

// DescriptionGT applies the GT predicate on the "description" field.
func DescriptionGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldDescription, v))
}

// DescriptionGTE applies the GTE predicate on the "description" field.
func DescriptionGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldDescription, v))
}

// DescriptionLT applies the LT predicate on the "description" field.
func DescriptionLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldDescription, v))
}

// DescriptionLTE applies the LTE predicate on the "description" field.
func DescriptionLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldDescription, v))
}

// DescriptionContains applies the Contains predicate on the "description" field.
func DescriptionContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldDescription, v))
}

// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
func DescriptionHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldDescription, v))
}

// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
func DescriptionHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldDescription, v))
}

// DescriptionIsNil applies the IsNil predicate on the "description" field.
func DescriptionIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldDescription))
}

// DescriptionNotNil applies the NotNil predicate on the "description" field.
func DescriptionNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldDescription))
}

// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
func DescriptionEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldDescription, v))
}

// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
func DescriptionContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldDescription, v))
}

// InputTypesEQ applies the EQ predicate on the "input_types" field.
func InputTypesEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldInputTypes, v))
}

// InputTypesNEQ applies the NEQ predicate on the "input_types" field.
func InputTypesNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldInputTypes, v))
}

// InputTypesIn applies the In predicate on the "input_types" field.
func InputTypesIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldInputTypes, vs...))
}

// InputTypesNotIn applies the NotIn predicate on the "input_types" field.
func InputTypesNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldInputTypes, vs...))
}

// InputTypesGT applies the GT predicate on the "input_types" field.
func InputTypesGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldInputTypes, v))
}

// InputTypesGTE applies the GTE predicate on the "input_types" field.
func InputTypesGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldInputTypes, v))
}

// InputTypesLT applies the LT predicate on the "input_types" field.
func InputTypesLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldInputTypes, v))
}

// InputTypesLTE applies the LTE predicate on the "input_types" field.
func InputTypesLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldInputTypes, v))
}

// InputTypesContains applies the Contains predicate on the "input_types" field.
func InputTypesContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldInputTypes, v))
}

// InputTypesHasPrefix applies the HasPrefix predicate on the "input_types" field.
func InputTypesHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldInputTypes, v))
}

// InputTypesHasSuffix applies the HasSuffix predicate on the "input_types" field.
func InputTypesHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldInputTypes, v))
}

// InputTypesIsNil applies the IsNil predicate on the "input_types" field.
func InputTypesIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldInputTypes))
}

// InputTypesNotNil applies the NotNil predicate on the "input_types" field.
func InputTypesNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldInputTypes))
}

// InputTypesEqualFold applies the EqualFold predicate on the "input_types" field.
func InputTypesEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldInputTypes, v))
}

// InputTypesContainsFold applies the ContainsFold predicate on the "input_types" field.
func InputTypesContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldInputTypes, v))
}

// DeprecatedEQ applies the EQ predicate on the "deprecated" field.
func DeprecatedEQ(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldDeprecated, v))
}

// DeprecatedNEQ applies the NEQ predicate on the "deprecated" field.
func DeprecatedNEQ(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldDeprecated, v))
}

// DeprecatedIsNil applies the IsNil predicate on the "deprecated" field.
func DeprecatedIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldDeprecated))
}

// DeprecatedNotNil applies the NotNil predicate on the "deprecated" field.
func DeprecatedNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldDeprecated))
}

// ExperimentalEQ applies the EQ predicate on the "experimental" field.
func ExperimentalEQ(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldExperimental, v))
}

// ExperimentalNEQ applies the NEQ predicate on the "experimental" field.
func ExperimentalNEQ(v bool) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldExperimental, v))
}

// ExperimentalIsNil applies the IsNil predicate on the "experimental" field.
func ExperimentalIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldExperimental))
}

// ExperimentalNotNil applies the NotNil predicate on the "experimental" field.
func ExperimentalNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldExperimental))
}

// OutputIsListIsNil applies the IsNil predicate on the "output_is_list" field.
func OutputIsListIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldOutputIsList))
}

// OutputIsListNotNil applies the NotNil predicate on the "output_is_list" field.
func OutputIsListNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldOutputIsList))
}

// ReturnNamesEQ applies the EQ predicate on the "return_names" field.
func ReturnNamesEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldReturnNames, v))
}

// ReturnNamesNEQ applies the NEQ predicate on the "return_names" field.
func ReturnNamesNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldReturnNames, v))
}

// ReturnNamesIn applies the In predicate on the "return_names" field.
func ReturnNamesIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldReturnNames, vs...))
}

// ReturnNamesNotIn applies the NotIn predicate on the "return_names" field.
func ReturnNamesNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldReturnNames, vs...))
}

// ReturnNamesGT applies the GT predicate on the "return_names" field.
func ReturnNamesGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldReturnNames, v))
}

// ReturnNamesGTE applies the GTE predicate on the "return_names" field.
func ReturnNamesGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldReturnNames, v))
}

// ReturnNamesLT applies the LT predicate on the "return_names" field.
func ReturnNamesLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldReturnNames, v))
}

// ReturnNamesLTE applies the LTE predicate on the "return_names" field.
func ReturnNamesLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldReturnNames, v))
}

// ReturnNamesContains applies the Contains predicate on the "return_names" field.
func ReturnNamesContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldReturnNames, v))
}

// ReturnNamesHasPrefix applies the HasPrefix predicate on the "return_names" field.
func ReturnNamesHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldReturnNames, v))
}

// ReturnNamesHasSuffix applies the HasSuffix predicate on the "return_names" field.
func ReturnNamesHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldReturnNames, v))
}

// ReturnNamesIsNil applies the IsNil predicate on the "return_names" field.
func ReturnNamesIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldReturnNames))
}

// ReturnNamesNotNil applies the NotNil predicate on the "return_names" field.
func ReturnNamesNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldReturnNames))
}

// ReturnNamesEqualFold applies the EqualFold predicate on the "return_names" field.
func ReturnNamesEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldReturnNames, v))
}

// ReturnNamesContainsFold applies the ContainsFold predicate on the "return_names" field.
func ReturnNamesContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldReturnNames, v))
}

// ReturnTypesEQ applies the EQ predicate on the "return_types" field.
func ReturnTypesEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldReturnTypes, v))
}

// ReturnTypesNEQ applies the NEQ predicate on the "return_types" field.
func ReturnTypesNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldReturnTypes, v))
}

// ReturnTypesIn applies the In predicate on the "return_types" field.
func ReturnTypesIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldReturnTypes, vs...))
}

// ReturnTypesNotIn applies the NotIn predicate on the "return_types" field.
func ReturnTypesNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldReturnTypes, vs...))
}

// ReturnTypesGT applies the GT predicate on the "return_types" field.
func ReturnTypesGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldReturnTypes, v))
}

// ReturnTypesGTE applies the GTE predicate on the "return_types" field.
func ReturnTypesGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldReturnTypes, v))
}

// ReturnTypesLT applies the LT predicate on the "return_types" field.
func ReturnTypesLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldReturnTypes, v))
}

// ReturnTypesLTE applies the LTE predicate on the "return_types" field.
func ReturnTypesLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldReturnTypes, v))
}

// ReturnTypesContains applies the Contains predicate on the "return_types" field.
func ReturnTypesContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldReturnTypes, v))
}

// ReturnTypesHasPrefix applies the HasPrefix predicate on the "return_types" field.
func ReturnTypesHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldReturnTypes, v))
}

// ReturnTypesHasSuffix applies the HasSuffix predicate on the "return_types" field.
func ReturnTypesHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldReturnTypes, v))
}

// ReturnTypesIsNil applies the IsNil predicate on the "return_types" field.
func ReturnTypesIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldReturnTypes))
}

// ReturnTypesNotNil applies the NotNil predicate on the "return_types" field.
func ReturnTypesNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldReturnTypes))
}

// ReturnTypesEqualFold applies the EqualFold predicate on the "return_types" field.
func ReturnTypesEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldReturnTypes, v))
}

// ReturnTypesContainsFold applies the ContainsFold predicate on the "return_types" field.
func ReturnTypesContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldReturnTypes, v))
}

// FunctionEQ applies the EQ predicate on the "function" field.
func FunctionEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEQ(FieldFunction, v))
}

// FunctionNEQ applies the NEQ predicate on the "function" field.
func FunctionNEQ(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNEQ(FieldFunction, v))
}

// FunctionIn applies the In predicate on the "function" field.
func FunctionIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIn(FieldFunction, vs...))
}

// FunctionNotIn applies the NotIn predicate on the "function" field.
func FunctionNotIn(vs ...string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotIn(FieldFunction, vs...))
}

// FunctionGT applies the GT predicate on the "function" field.
func FunctionGT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGT(FieldFunction, v))
}

// FunctionGTE applies the GTE predicate on the "function" field.
func FunctionGTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldGTE(FieldFunction, v))
}

// FunctionLT applies the LT predicate on the "function" field.
func FunctionLT(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLT(FieldFunction, v))
}

// FunctionLTE applies the LTE predicate on the "function" field.
func FunctionLTE(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldLTE(FieldFunction, v))
}

// FunctionContains applies the Contains predicate on the "function" field.
func FunctionContains(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContains(FieldFunction, v))
}

// FunctionHasPrefix applies the HasPrefix predicate on the "function" field.
func FunctionHasPrefix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasPrefix(FieldFunction, v))
}

// FunctionHasSuffix applies the HasSuffix predicate on the "function" field.
func FunctionHasSuffix(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldHasSuffix(FieldFunction, v))
}

// FunctionIsNil applies the IsNil predicate on the "function" field.
func FunctionIsNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldIsNull(FieldFunction))
}

// FunctionNotNil applies the NotNil predicate on the "function" field.
func FunctionNotNil() predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldNotNull(FieldFunction))
}

// FunctionEqualFold applies the EqualFold predicate on the "function" field.
func FunctionEqualFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldEqualFold(FieldFunction, v))
}

// FunctionContainsFold applies the ContainsFold predicate on the "function" field.
func FunctionContainsFold(v string) predicate.ComfyNode {
	return predicate.ComfyNode(sql.FieldContainsFold(FieldFunction, v))
}

// HasVersions applies the HasEdge predicate on the "versions" edge.
func HasVersions() predicate.ComfyNode {
	return predicate.ComfyNode(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, VersionsTable, VersionsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasVersionsWith applies the HasEdge predicate on the "versions" edge with a given conditions (other predicates).
func HasVersionsWith(preds ...predicate.NodeVersion) predicate.ComfyNode {
	return predicate.ComfyNode(func(s *sql.Selector) {
		step := newVersionsStep()
		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.ComfyNode) predicate.ComfyNode {
	return predicate.ComfyNode(sql.AndPredicates(predicates...))
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.ComfyNode) predicate.ComfyNode {
	return predicate.ComfyNode(sql.OrPredicates(predicates...))
}

// Not applies the not operator on the given predicate.
func Not(p predicate.ComfyNode) predicate.ComfyNode {
	return predicate.ComfyNode(sql.NotPredicates(p))
}