github.com/ngocphuongnb/tetua@v0.0.7-alpha/packages/entrepository/ent/entql.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/comment"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/file"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/page"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/permission"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/post"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/predicate"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/role"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/setting"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/topic"
	"github.com/ngocphuongnb/tetua/packages/entrepository/ent/user"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/entql"
	"entgo.io/ent/schema/field"
)

// schemaGraph holds a representation of ent/schema at runtime.
var schemaGraph = func() *sqlgraph.Schema {
	graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 9)}
	graph.Nodes[0] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   comment.Table,
			Columns: comment.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: comment.FieldID,
			},
		},
		Type: "Comment",
		Fields: map[string]*sqlgraph.FieldSpec{
			comment.FieldCreatedAt:   {Type: field.TypeTime, Column: comment.FieldCreatedAt},
			comment.FieldUpdatedAt:   {Type: field.TypeTime, Column: comment.FieldUpdatedAt},
			comment.FieldDeletedAt:   {Type: field.TypeTime, Column: comment.FieldDeletedAt},
			comment.FieldContent:     {Type: field.TypeString, Column: comment.FieldContent},
			comment.FieldContentHTML: {Type: field.TypeString, Column: comment.FieldContentHTML},
			comment.FieldVotes:       {Type: field.TypeInt64, Column: comment.FieldVotes},
			comment.FieldPostID:      {Type: field.TypeInt, Column: comment.FieldPostID},
			comment.FieldUserID:      {Type: field.TypeInt, Column: comment.FieldUserID},
			comment.FieldParentID:    {Type: field.TypeInt, Column: comment.FieldParentID},
		},
	}
	graph.Nodes[1] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   file.Table,
			Columns: file.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: file.FieldID,
			},
		},
		Type: "File",
		Fields: map[string]*sqlgraph.FieldSpec{
			file.FieldCreatedAt: {Type: field.TypeTime, Column: file.FieldCreatedAt},
			file.FieldUpdatedAt: {Type: field.TypeTime, Column: file.FieldUpdatedAt},
			file.FieldDeletedAt: {Type: field.TypeTime, Column: file.FieldDeletedAt},
			file.FieldDisk:      {Type: field.TypeString, Column: file.FieldDisk},
			file.FieldPath:      {Type: field.TypeString, Column: file.FieldPath},
			file.FieldType:      {Type: field.TypeString, Column: file.FieldType},
			file.FieldSize:      {Type: field.TypeInt, Column: file.FieldSize},
			file.FieldUserID:    {Type: field.TypeInt, Column: file.FieldUserID},
		},
	}
	graph.Nodes[2] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   page.Table,
			Columns: page.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: page.FieldID,
			},
		},
		Type: "Page",
		Fields: map[string]*sqlgraph.FieldSpec{
			page.FieldCreatedAt:       {Type: field.TypeTime, Column: page.FieldCreatedAt},
			page.FieldUpdatedAt:       {Type: field.TypeTime, Column: page.FieldUpdatedAt},
			page.FieldDeletedAt:       {Type: field.TypeTime, Column: page.FieldDeletedAt},
			page.FieldName:            {Type: field.TypeString, Column: page.FieldName},
			page.FieldSlug:            {Type: field.TypeString, Column: page.FieldSlug},
			page.FieldContent:         {Type: field.TypeString, Column: page.FieldContent},
			page.FieldContentHTML:     {Type: field.TypeString, Column: page.FieldContentHTML},
			page.FieldDraft:           {Type: field.TypeBool, Column: page.FieldDraft},
			page.FieldFeaturedImageID: {Type: field.TypeInt, Column: page.FieldFeaturedImageID},
		},
	}
	graph.Nodes[3] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   permission.Table,
			Columns: permission.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: permission.FieldID,
			},
		},
		Type: "Permission",
		Fields: map[string]*sqlgraph.FieldSpec{
			permission.FieldCreatedAt: {Type: field.TypeTime, Column: permission.FieldCreatedAt},
			permission.FieldUpdatedAt: {Type: field.TypeTime, Column: permission.FieldUpdatedAt},
			permission.FieldDeletedAt: {Type: field.TypeTime, Column: permission.FieldDeletedAt},
			permission.FieldRoleID:    {Type: field.TypeInt, Column: permission.FieldRoleID},
			permission.FieldAction:    {Type: field.TypeString, Column: permission.FieldAction},
			permission.FieldValue:     {Type: field.TypeString, Column: permission.FieldValue},
		},
	}
	graph.Nodes[4] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   post.Table,
			Columns: post.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: post.FieldID,
			},
		},
		Type: "Post",
		Fields: map[string]*sqlgraph.FieldSpec{
			post.FieldCreatedAt:       {Type: field.TypeTime, Column: post.FieldCreatedAt},
			post.FieldUpdatedAt:       {Type: field.TypeTime, Column: post.FieldUpdatedAt},
			post.FieldDeletedAt:       {Type: field.TypeTime, Column: post.FieldDeletedAt},
			post.FieldName:            {Type: field.TypeString, Column: post.FieldName},
			post.FieldSlug:            {Type: field.TypeString, Column: post.FieldSlug},
			post.FieldDescription:     {Type: field.TypeString, Column: post.FieldDescription},
			post.FieldContent:         {Type: field.TypeString, Column: post.FieldContent},
			post.FieldContentHTML:     {Type: field.TypeString, Column: post.FieldContentHTML},
			post.FieldViewCount:       {Type: field.TypeInt64, Column: post.FieldViewCount},
			post.FieldCommentCount:    {Type: field.TypeInt64, Column: post.FieldCommentCount},
			post.FieldRatingCount:     {Type: field.TypeInt64, Column: post.FieldRatingCount},
			post.FieldRatingTotal:     {Type: field.TypeInt64, Column: post.FieldRatingTotal},
			post.FieldDraft:           {Type: field.TypeBool, Column: post.FieldDraft},
			post.FieldApproved:        {Type: field.TypeBool, Column: post.FieldApproved},
			post.FieldFeaturedImageID: {Type: field.TypeInt, Column: post.FieldFeaturedImageID},
			post.FieldUserID:          {Type: field.TypeInt, Column: post.FieldUserID},
		},
	}
	graph.Nodes[5] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   role.Table,
			Columns: role.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: role.FieldID,
			},
		},
		Type: "Role",
		Fields: map[string]*sqlgraph.FieldSpec{
			role.FieldCreatedAt:   {Type: field.TypeTime, Column: role.FieldCreatedAt},
			role.FieldUpdatedAt:   {Type: field.TypeTime, Column: role.FieldUpdatedAt},
			role.FieldDeletedAt:   {Type: field.TypeTime, Column: role.FieldDeletedAt},
			role.FieldName:        {Type: field.TypeString, Column: role.FieldName},
			role.FieldDescription: {Type: field.TypeString, Column: role.FieldDescription},
			role.FieldRoot:        {Type: field.TypeBool, Column: role.FieldRoot},
		},
	}
	graph.Nodes[6] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   setting.Table,
			Columns: setting.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: setting.FieldID,
			},
		},
		Type: "Setting",
		Fields: map[string]*sqlgraph.FieldSpec{
			setting.FieldCreatedAt: {Type: field.TypeTime, Column: setting.FieldCreatedAt},
			setting.FieldUpdatedAt: {Type: field.TypeTime, Column: setting.FieldUpdatedAt},
			setting.FieldDeletedAt: {Type: field.TypeTime, Column: setting.FieldDeletedAt},
			setting.FieldName:      {Type: field.TypeString, Column: setting.FieldName},
			setting.FieldValue:     {Type: field.TypeString, Column: setting.FieldValue},
			setting.FieldType:      {Type: field.TypeString, Column: setting.FieldType},
		},
	}
	graph.Nodes[7] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   topic.Table,
			Columns: topic.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: topic.FieldID,
			},
		},
		Type: "Topic",
		Fields: map[string]*sqlgraph.FieldSpec{
			topic.FieldCreatedAt:   {Type: field.TypeTime, Column: topic.FieldCreatedAt},
			topic.FieldUpdatedAt:   {Type: field.TypeTime, Column: topic.FieldUpdatedAt},
			topic.FieldDeletedAt:   {Type: field.TypeTime, Column: topic.FieldDeletedAt},
			topic.FieldName:        {Type: field.TypeString, Column: topic.FieldName},
			topic.FieldSlug:        {Type: field.TypeString, Column: topic.FieldSlug},
			topic.FieldDescription: {Type: field.TypeString, Column: topic.FieldDescription},
			topic.FieldContent:     {Type: field.TypeString, Column: topic.FieldContent},
			topic.FieldContentHTML: {Type: field.TypeString, Column: topic.FieldContentHTML},
			topic.FieldParentID:    {Type: field.TypeInt, Column: topic.FieldParentID},
		},
	}
	graph.Nodes[8] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   user.Table,
			Columns: user.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: user.FieldID,
			},
		},
		Type: "User",
		Fields: map[string]*sqlgraph.FieldSpec{
			user.FieldCreatedAt:        {Type: field.TypeTime, Column: user.FieldCreatedAt},
			user.FieldUpdatedAt:        {Type: field.TypeTime, Column: user.FieldUpdatedAt},
			user.FieldDeletedAt:        {Type: field.TypeTime, Column: user.FieldDeletedAt},
			user.FieldUsername:         {Type: field.TypeString, Column: user.FieldUsername},
			user.FieldDisplayName:      {Type: field.TypeString, Column: user.FieldDisplayName},
			user.FieldURL:              {Type: field.TypeString, Column: user.FieldURL},
			user.FieldProvider:         {Type: field.TypeString, Column: user.FieldProvider},
			user.FieldProviderID:       {Type: field.TypeString, Column: user.FieldProviderID},
			user.FieldProviderUsername: {Type: field.TypeString, Column: user.FieldProviderUsername},
			user.FieldProviderAvatar:   {Type: field.TypeString, Column: user.FieldProviderAvatar},
			user.FieldEmail:            {Type: field.TypeString, Column: user.FieldEmail},
			user.FieldPassword:         {Type: field.TypeString, Column: user.FieldPassword},
			user.FieldBio:              {Type: field.TypeString, Column: user.FieldBio},
			user.FieldBioHTML:          {Type: field.TypeString, Column: user.FieldBioHTML},
			user.FieldActive:           {Type: field.TypeBool, Column: user.FieldActive},
			user.FieldAvatarImageID:    {Type: field.TypeInt, Column: user.FieldAvatarImageID},
		},
	}
	graph.MustAddE(
		"post",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   comment.PostTable,
			Columns: []string{comment.PostColumn},
			Bidi:    false,
		},
		"Comment",
		"Post",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   comment.UserTable,
			Columns: []string{comment.UserColumn},
			Bidi:    false,
		},
		"Comment",
		"User",
	)
	graph.MustAddE(
		"children",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   comment.ChildrenTable,
			Columns: []string{comment.ChildrenColumn},
			Bidi:    true,
		},
		"Comment",
		"Comment",
	)
	graph.MustAddE(
		"parent",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   comment.ParentTable,
			Columns: []string{comment.ParentColumn},
			Bidi:    false,
		},
		"Comment",
		"Comment",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   file.UserTable,
			Columns: []string{file.UserColumn},
			Bidi:    false,
		},
		"File",
		"User",
	)
	graph.MustAddE(
		"posts",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   file.PostsTable,
			Columns: []string{file.PostsColumn},
			Bidi:    false,
		},
		"File",
		"Post",
	)
	graph.MustAddE(
		"pages",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   file.PagesTable,
			Columns: []string{file.PagesColumn},
			Bidi:    false,
		},
		"File",
		"Page",
	)
	graph.MustAddE(
		"user_avatars",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   file.UserAvatarsTable,
			Columns: []string{file.UserAvatarsColumn},
			Bidi:    false,
		},
		"File",
		"User",
	)
	graph.MustAddE(
		"featured_image",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   page.FeaturedImageTable,
			Columns: []string{page.FeaturedImageColumn},
			Bidi:    false,
		},
		"Page",
		"File",
	)
	graph.MustAddE(
		"role",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   permission.RoleTable,
			Columns: []string{permission.RoleColumn},
			Bidi:    false,
		},
		"Permission",
		"Role",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   post.UserTable,
			Columns: []string{post.UserColumn},
			Bidi:    false,
		},
		"Post",
		"User",
	)
	graph.MustAddE(
		"topics",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   post.TopicsTable,
			Columns: post.TopicsPrimaryKey,
			Bidi:    false,
		},
		"Post",
		"Topic",
	)
	graph.MustAddE(
		"featured_image",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   post.FeaturedImageTable,
			Columns: []string{post.FeaturedImageColumn},
			Bidi:    false,
		},
		"Post",
		"File",
	)
	graph.MustAddE(
		"comments",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   post.CommentsTable,
			Columns: []string{post.CommentsColumn},
			Bidi:    false,
		},
		"Post",
		"Comment",
	)
	graph.MustAddE(
		"permissions",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   role.PermissionsTable,
			Columns: []string{role.PermissionsColumn},
			Bidi:    false,
		},
		"Role",
		"Permission",
	)
	graph.MustAddE(
		"users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   role.UsersTable,
			Columns: role.UsersPrimaryKey,
			Bidi:    false,
		},
		"Role",
		"User",
	)
	graph.MustAddE(
		"posts",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   topic.PostsTable,
			Columns: topic.PostsPrimaryKey,
			Bidi:    false,
		},
		"Topic",
		"Post",
	)
	graph.MustAddE(
		"children",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   topic.ChildrenTable,
			Columns: []string{topic.ChildrenColumn},
			Bidi:    true,
		},
		"Topic",
		"Topic",
	)
	graph.MustAddE(
		"parent",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   topic.ParentTable,
			Columns: []string{topic.ParentColumn},
			Bidi:    false,
		},
		"Topic",
		"Topic",
	)
	graph.MustAddE(
		"posts",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.PostsTable,
			Columns: []string{user.PostsColumn},
			Bidi:    false,
		},
		"User",
		"Post",
	)
	graph.MustAddE(
		"files",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.FilesTable,
			Columns: []string{user.FilesColumn},
			Bidi:    false,
		},
		"User",
		"File",
	)
	graph.MustAddE(
		"comments",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   user.CommentsTable,
			Columns: []string{user.CommentsColumn},
			Bidi:    false,
		},
		"User",
		"Comment",
	)
	graph.MustAddE(
		"roles",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   user.RolesTable,
			Columns: user.RolesPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Role",
	)
	graph.MustAddE(
		"avatar_image",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   user.AvatarImageTable,
			Columns: []string{user.AvatarImageColumn},
			Bidi:    false,
		},
		"User",
		"File",
	)
	return graph
}()

// predicateAdder wraps the addPredicate method.
// All update, update-one and query builders implement this interface.
type predicateAdder interface {
	addPredicate(func(s *sql.Selector))
}

// addPredicate implements the predicateAdder interface.
func (cq *CommentQuery) addPredicate(pred func(s *sql.Selector)) {
	cq.predicates = append(cq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the CommentQuery builder.
func (cq *CommentQuery) Filter() *CommentFilter {
	return &CommentFilter{cq}
}

// addPredicate implements the predicateAdder interface.
func (m *CommentMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the CommentMutation builder.
func (m *CommentMutation) Filter() *CommentFilter {
	return &CommentFilter{m}
}

// CommentFilter provides a generic filtering capability at runtime for CommentQuery.
type CommentFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *CommentFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[0].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *CommentFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(comment.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *CommentFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(comment.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *CommentFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(comment.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *CommentFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(comment.FieldDeletedAt))
}

// WhereContent applies the entql string predicate on the content field.
func (f *CommentFilter) WhereContent(p entql.StringP) {
	f.Where(p.Field(comment.FieldContent))
}

// WhereContentHTML applies the entql string predicate on the content_html field.
func (f *CommentFilter) WhereContentHTML(p entql.StringP) {
	f.Where(p.Field(comment.FieldContentHTML))
}

// WhereVotes applies the entql int64 predicate on the votes field.
func (f *CommentFilter) WhereVotes(p entql.Int64P) {
	f.Where(p.Field(comment.FieldVotes))
}

// WherePostID applies the entql int predicate on the post_id field.
func (f *CommentFilter) WherePostID(p entql.IntP) {
	f.Where(p.Field(comment.FieldPostID))
}

// WhereUserID applies the entql int predicate on the user_id field.
func (f *CommentFilter) WhereUserID(p entql.IntP) {
	f.Where(p.Field(comment.FieldUserID))
}

// WhereParentID applies the entql int predicate on the parent_id field.
func (f *CommentFilter) WhereParentID(p entql.IntP) {
	f.Where(p.Field(comment.FieldParentID))
}

// WhereHasPost applies a predicate to check if query has an edge post.
func (f *CommentFilter) WhereHasPost() {
	f.Where(entql.HasEdge("post"))
}

// WhereHasPostWith applies a predicate to check if query has an edge post with a given conditions (other predicates).
func (f *CommentFilter) WhereHasPostWith(preds ...predicate.Post) {
	f.Where(entql.HasEdgeWith("post", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *CommentFilter) WhereHasUser() {
	f.Where(entql.HasEdge("user"))
}

// WhereHasUserWith applies a predicate to check if query has an edge user with a given conditions (other predicates).
func (f *CommentFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasChildren applies a predicate to check if query has an edge children.
func (f *CommentFilter) WhereHasChildren() {
	f.Where(entql.HasEdge("children"))
}

// WhereHasChildrenWith applies a predicate to check if query has an edge children with a given conditions (other predicates).
func (f *CommentFilter) WhereHasChildrenWith(preds ...predicate.Comment) {
	f.Where(entql.HasEdgeWith("children", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasParent applies a predicate to check if query has an edge parent.
func (f *CommentFilter) WhereHasParent() {
	f.Where(entql.HasEdge("parent"))
}

// WhereHasParentWith applies a predicate to check if query has an edge parent with a given conditions (other predicates).
func (f *CommentFilter) WhereHasParentWith(preds ...predicate.Comment) {
	f.Where(entql.HasEdgeWith("parent", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (fq *FileQuery) addPredicate(pred func(s *sql.Selector)) {
	fq.predicates = append(fq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the FileQuery builder.
func (fq *FileQuery) Filter() *FileFilter {
	return &FileFilter{fq}
}

// addPredicate implements the predicateAdder interface.
func (m *FileMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the FileMutation builder.
func (m *FileMutation) Filter() *FileFilter {
	return &FileFilter{m}
}

// FileFilter provides a generic filtering capability at runtime for FileQuery.
type FileFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *FileFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[1].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *FileFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(file.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *FileFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(file.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *FileFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(file.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *FileFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(file.FieldDeletedAt))
}

// WhereDisk applies the entql string predicate on the disk field.
func (f *FileFilter) WhereDisk(p entql.StringP) {
	f.Where(p.Field(file.FieldDisk))
}

// WherePath applies the entql string predicate on the path field.
func (f *FileFilter) WherePath(p entql.StringP) {
	f.Where(p.Field(file.FieldPath))
}

// WhereType applies the entql string predicate on the type field.
func (f *FileFilter) WhereType(p entql.StringP) {
	f.Where(p.Field(file.FieldType))
}

// WhereSize applies the entql int predicate on the size field.
func (f *FileFilter) WhereSize(p entql.IntP) {
	f.Where(p.Field(file.FieldSize))
}

// WhereUserID applies the entql int predicate on the user_id field.
func (f *FileFilter) WhereUserID(p entql.IntP) {
	f.Where(p.Field(file.FieldUserID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *FileFilter) WhereHasUser() {
	f.Where(entql.HasEdge("user"))
}

// WhereHasUserWith applies a predicate to check if query has an edge user with a given conditions (other predicates).
func (f *FileFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasPosts applies a predicate to check if query has an edge posts.
func (f *FileFilter) WhereHasPosts() {
	f.Where(entql.HasEdge("posts"))
}

// WhereHasPostsWith applies a predicate to check if query has an edge posts with a given conditions (other predicates).
func (f *FileFilter) WhereHasPostsWith(preds ...predicate.Post) {
	f.Where(entql.HasEdgeWith("posts", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasPages applies a predicate to check if query has an edge pages.
func (f *FileFilter) WhereHasPages() {
	f.Where(entql.HasEdge("pages"))
}

// WhereHasPagesWith applies a predicate to check if query has an edge pages with a given conditions (other predicates).
func (f *FileFilter) WhereHasPagesWith(preds ...predicate.Page) {
	f.Where(entql.HasEdgeWith("pages", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasUserAvatars applies a predicate to check if query has an edge user_avatars.
func (f *FileFilter) WhereHasUserAvatars() {
	f.Where(entql.HasEdge("user_avatars"))
}

// WhereHasUserAvatarsWith applies a predicate to check if query has an edge user_avatars with a given conditions (other predicates).
func (f *FileFilter) WhereHasUserAvatarsWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user_avatars", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (pq *PageQuery) addPredicate(pred func(s *sql.Selector)) {
	pq.predicates = append(pq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the PageQuery builder.
func (pq *PageQuery) Filter() *PageFilter {
	return &PageFilter{pq}
}

// addPredicate implements the predicateAdder interface.
func (m *PageMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the PageMutation builder.
func (m *PageMutation) Filter() *PageFilter {
	return &PageFilter{m}
}

// PageFilter provides a generic filtering capability at runtime for PageQuery.
type PageFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *PageFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[2].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *PageFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(page.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *PageFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(page.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *PageFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(page.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *PageFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(page.FieldDeletedAt))
}

// WhereName applies the entql string predicate on the name field.
func (f *PageFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(page.FieldName))
}

// WhereSlug applies the entql string predicate on the slug field.
func (f *PageFilter) WhereSlug(p entql.StringP) {
	f.Where(p.Field(page.FieldSlug))
}

// WhereContent applies the entql string predicate on the content field.
func (f *PageFilter) WhereContent(p entql.StringP) {
	f.Where(p.Field(page.FieldContent))
}

// WhereContentHTML applies the entql string predicate on the content_html field.
func (f *PageFilter) WhereContentHTML(p entql.StringP) {
	f.Where(p.Field(page.FieldContentHTML))
}

// WhereDraft applies the entql bool predicate on the draft field.
func (f *PageFilter) WhereDraft(p entql.BoolP) {
	f.Where(p.Field(page.FieldDraft))
}

// WhereFeaturedImageID applies the entql int predicate on the featured_image_id field.
func (f *PageFilter) WhereFeaturedImageID(p entql.IntP) {
	f.Where(p.Field(page.FieldFeaturedImageID))
}

// WhereHasFeaturedImage applies a predicate to check if query has an edge featured_image.
func (f *PageFilter) WhereHasFeaturedImage() {
	f.Where(entql.HasEdge("featured_image"))
}

// WhereHasFeaturedImageWith applies a predicate to check if query has an edge featured_image with a given conditions (other predicates).
func (f *PageFilter) WhereHasFeaturedImageWith(preds ...predicate.File) {
	f.Where(entql.HasEdgeWith("featured_image", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (pq *PermissionQuery) addPredicate(pred func(s *sql.Selector)) {
	pq.predicates = append(pq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the PermissionQuery builder.
func (pq *PermissionQuery) Filter() *PermissionFilter {
	return &PermissionFilter{pq}
}

// addPredicate implements the predicateAdder interface.
func (m *PermissionMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the PermissionMutation builder.
func (m *PermissionMutation) Filter() *PermissionFilter {
	return &PermissionFilter{m}
}

// PermissionFilter provides a generic filtering capability at runtime for PermissionQuery.
type PermissionFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *PermissionFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[3].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *PermissionFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(permission.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *PermissionFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(permission.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *PermissionFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(permission.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *PermissionFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(permission.FieldDeletedAt))
}

// WhereRoleID applies the entql int predicate on the role_id field.
func (f *PermissionFilter) WhereRoleID(p entql.IntP) {
	f.Where(p.Field(permission.FieldRoleID))
}

// WhereAction applies the entql string predicate on the action field.
func (f *PermissionFilter) WhereAction(p entql.StringP) {
	f.Where(p.Field(permission.FieldAction))
}

// WhereValue applies the entql string predicate on the value field.
func (f *PermissionFilter) WhereValue(p entql.StringP) {
	f.Where(p.Field(permission.FieldValue))
}

// WhereHasRole applies a predicate to check if query has an edge role.
func (f *PermissionFilter) WhereHasRole() {
	f.Where(entql.HasEdge("role"))
}

// WhereHasRoleWith applies a predicate to check if query has an edge role with a given conditions (other predicates).
func (f *PermissionFilter) WhereHasRoleWith(preds ...predicate.Role) {
	f.Where(entql.HasEdgeWith("role", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (pq *PostQuery) addPredicate(pred func(s *sql.Selector)) {
	pq.predicates = append(pq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the PostQuery builder.
func (pq *PostQuery) Filter() *PostFilter {
	return &PostFilter{pq}
}

// addPredicate implements the predicateAdder interface.
func (m *PostMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the PostMutation builder.
func (m *PostMutation) Filter() *PostFilter {
	return &PostFilter{m}
}

// PostFilter provides a generic filtering capability at runtime for PostQuery.
type PostFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *PostFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[4].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *PostFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(post.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *PostFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(post.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *PostFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(post.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *PostFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(post.FieldDeletedAt))
}

// WhereName applies the entql string predicate on the name field.
func (f *PostFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(post.FieldName))
}

// WhereSlug applies the entql string predicate on the slug field.
func (f *PostFilter) WhereSlug(p entql.StringP) {
	f.Where(p.Field(post.FieldSlug))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *PostFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(post.FieldDescription))
}

// WhereContent applies the entql string predicate on the content field.
func (f *PostFilter) WhereContent(p entql.StringP) {
	f.Where(p.Field(post.FieldContent))
}

// WhereContentHTML applies the entql string predicate on the content_html field.
func (f *PostFilter) WhereContentHTML(p entql.StringP) {
	f.Where(p.Field(post.FieldContentHTML))
}

// WhereViewCount applies the entql int64 predicate on the view_count field.
func (f *PostFilter) WhereViewCount(p entql.Int64P) {
	f.Where(p.Field(post.FieldViewCount))
}

// WhereCommentCount applies the entql int64 predicate on the comment_count field.
func (f *PostFilter) WhereCommentCount(p entql.Int64P) {
	f.Where(p.Field(post.FieldCommentCount))
}

// WhereRatingCount applies the entql int64 predicate on the rating_count field.
func (f *PostFilter) WhereRatingCount(p entql.Int64P) {
	f.Where(p.Field(post.FieldRatingCount))
}

// WhereRatingTotal applies the entql int64 predicate on the rating_total field.
func (f *PostFilter) WhereRatingTotal(p entql.Int64P) {
	f.Where(p.Field(post.FieldRatingTotal))
}

// WhereDraft applies the entql bool predicate on the draft field.
func (f *PostFilter) WhereDraft(p entql.BoolP) {
	f.Where(p.Field(post.FieldDraft))
}

// WhereApproved applies the entql bool predicate on the approved field.
func (f *PostFilter) WhereApproved(p entql.BoolP) {
	f.Where(p.Field(post.FieldApproved))
}

// WhereFeaturedImageID applies the entql int predicate on the featured_image_id field.
func (f *PostFilter) WhereFeaturedImageID(p entql.IntP) {
	f.Where(p.Field(post.FieldFeaturedImageID))
}

// WhereUserID applies the entql int predicate on the user_id field.
func (f *PostFilter) WhereUserID(p entql.IntP) {
	f.Where(p.Field(post.FieldUserID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *PostFilter) WhereHasUser() {
	f.Where(entql.HasEdge("user"))
}

// WhereHasUserWith applies a predicate to check if query has an edge user with a given conditions (other predicates).
func (f *PostFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasTopics applies a predicate to check if query has an edge topics.
func (f *PostFilter) WhereHasTopics() {
	f.Where(entql.HasEdge("topics"))
}

// WhereHasTopicsWith applies a predicate to check if query has an edge topics with a given conditions (other predicates).
func (f *PostFilter) WhereHasTopicsWith(preds ...predicate.Topic) {
	f.Where(entql.HasEdgeWith("topics", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasFeaturedImage applies a predicate to check if query has an edge featured_image.
func (f *PostFilter) WhereHasFeaturedImage() {
	f.Where(entql.HasEdge("featured_image"))
}

// WhereHasFeaturedImageWith applies a predicate to check if query has an edge featured_image with a given conditions (other predicates).
func (f *PostFilter) WhereHasFeaturedImageWith(preds ...predicate.File) {
	f.Where(entql.HasEdgeWith("featured_image", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasComments applies a predicate to check if query has an edge comments.
func (f *PostFilter) WhereHasComments() {
	f.Where(entql.HasEdge("comments"))
}

// WhereHasCommentsWith applies a predicate to check if query has an edge comments with a given conditions (other predicates).
func (f *PostFilter) WhereHasCommentsWith(preds ...predicate.Comment) {
	f.Where(entql.HasEdgeWith("comments", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (rq *RoleQuery) addPredicate(pred func(s *sql.Selector)) {
	rq.predicates = append(rq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the RoleQuery builder.
func (rq *RoleQuery) Filter() *RoleFilter {
	return &RoleFilter{rq}
}

// addPredicate implements the predicateAdder interface.
func (m *RoleMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the RoleMutation builder.
func (m *RoleMutation) Filter() *RoleFilter {
	return &RoleFilter{m}
}

// RoleFilter provides a generic filtering capability at runtime for RoleQuery.
type RoleFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *RoleFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[5].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *RoleFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(role.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *RoleFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(role.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *RoleFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(role.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *RoleFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(role.FieldDeletedAt))
}

// WhereName applies the entql string predicate on the name field.
func (f *RoleFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(role.FieldName))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *RoleFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(role.FieldDescription))
}

// WhereRoot applies the entql bool predicate on the root field.
func (f *RoleFilter) WhereRoot(p entql.BoolP) {
	f.Where(p.Field(role.FieldRoot))
}

// WhereHasPermissions applies a predicate to check if query has an edge permissions.
func (f *RoleFilter) WhereHasPermissions() {
	f.Where(entql.HasEdge("permissions"))
}

// WhereHasPermissionsWith applies a predicate to check if query has an edge permissions with a given conditions (other predicates).
func (f *RoleFilter) WhereHasPermissionsWith(preds ...predicate.Permission) {
	f.Where(entql.HasEdgeWith("permissions", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasUsers applies a predicate to check if query has an edge users.
func (f *RoleFilter) WhereHasUsers() {
	f.Where(entql.HasEdge("users"))
}

// WhereHasUsersWith applies a predicate to check if query has an edge users with a given conditions (other predicates).
func (f *RoleFilter) WhereHasUsersWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("users", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (sq *SettingQuery) addPredicate(pred func(s *sql.Selector)) {
	sq.predicates = append(sq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the SettingQuery builder.
func (sq *SettingQuery) Filter() *SettingFilter {
	return &SettingFilter{sq}
}

// addPredicate implements the predicateAdder interface.
func (m *SettingMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the SettingMutation builder.
func (m *SettingMutation) Filter() *SettingFilter {
	return &SettingFilter{m}
}

// SettingFilter provides a generic filtering capability at runtime for SettingQuery.
type SettingFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *SettingFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[6].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *SettingFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(setting.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *SettingFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(setting.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *SettingFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(setting.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *SettingFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(setting.FieldDeletedAt))
}

// WhereName applies the entql string predicate on the name field.
func (f *SettingFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(setting.FieldName))
}

// WhereValue applies the entql string predicate on the value field.
func (f *SettingFilter) WhereValue(p entql.StringP) {
	f.Where(p.Field(setting.FieldValue))
}

// WhereType applies the entql string predicate on the type field.
func (f *SettingFilter) WhereType(p entql.StringP) {
	f.Where(p.Field(setting.FieldType))
}

// addPredicate implements the predicateAdder interface.
func (tq *TopicQuery) addPredicate(pred func(s *sql.Selector)) {
	tq.predicates = append(tq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the TopicQuery builder.
func (tq *TopicQuery) Filter() *TopicFilter {
	return &TopicFilter{tq}
}

// addPredicate implements the predicateAdder interface.
func (m *TopicMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the TopicMutation builder.
func (m *TopicMutation) Filter() *TopicFilter {
	return &TopicFilter{m}
}

// TopicFilter provides a generic filtering capability at runtime for TopicQuery.
type TopicFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *TopicFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[7].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *TopicFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(topic.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *TopicFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(topic.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *TopicFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(topic.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *TopicFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(topic.FieldDeletedAt))
}

// WhereName applies the entql string predicate on the name field.
func (f *TopicFilter) WhereName(p entql.StringP) {
	f.Where(p.Field(topic.FieldName))
}

// WhereSlug applies the entql string predicate on the slug field.
func (f *TopicFilter) WhereSlug(p entql.StringP) {
	f.Where(p.Field(topic.FieldSlug))
}

// WhereDescription applies the entql string predicate on the description field.
func (f *TopicFilter) WhereDescription(p entql.StringP) {
	f.Where(p.Field(topic.FieldDescription))
}

// WhereContent applies the entql string predicate on the content field.
func (f *TopicFilter) WhereContent(p entql.StringP) {
	f.Where(p.Field(topic.FieldContent))
}

// WhereContentHTML applies the entql string predicate on the content_html field.
func (f *TopicFilter) WhereContentHTML(p entql.StringP) {
	f.Where(p.Field(topic.FieldContentHTML))
}

// WhereParentID applies the entql int predicate on the parent_id field.
func (f *TopicFilter) WhereParentID(p entql.IntP) {
	f.Where(p.Field(topic.FieldParentID))
}

// WhereHasPosts applies a predicate to check if query has an edge posts.
func (f *TopicFilter) WhereHasPosts() {
	f.Where(entql.HasEdge("posts"))
}

// WhereHasPostsWith applies a predicate to check if query has an edge posts with a given conditions (other predicates).
func (f *TopicFilter) WhereHasPostsWith(preds ...predicate.Post) {
	f.Where(entql.HasEdgeWith("posts", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasChildren applies a predicate to check if query has an edge children.
func (f *TopicFilter) WhereHasChildren() {
	f.Where(entql.HasEdge("children"))
}

// WhereHasChildrenWith applies a predicate to check if query has an edge children with a given conditions (other predicates).
func (f *TopicFilter) WhereHasChildrenWith(preds ...predicate.Topic) {
	f.Where(entql.HasEdgeWith("children", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasParent applies a predicate to check if query has an edge parent.
func (f *TopicFilter) WhereHasParent() {
	f.Where(entql.HasEdge("parent"))
}

// WhereHasParentWith applies a predicate to check if query has an edge parent with a given conditions (other predicates).
func (f *TopicFilter) WhereHasParentWith(preds ...predicate.Topic) {
	f.Where(entql.HasEdgeWith("parent", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// addPredicate implements the predicateAdder interface.
func (uq *UserQuery) addPredicate(pred func(s *sql.Selector)) {
	uq.predicates = append(uq.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the UserQuery builder.
func (uq *UserQuery) Filter() *UserFilter {
	return &UserFilter{uq}
}

// addPredicate implements the predicateAdder interface.
func (m *UserMutation) addPredicate(pred func(s *sql.Selector)) {
	m.predicates = append(m.predicates, pred)
}

// Filter returns an entql.Where implementation to apply filters on the UserMutation builder.
func (m *UserMutation) Filter() *UserFilter {
	return &UserFilter{m}
}

// UserFilter provides a generic filtering capability at runtime for UserQuery.
type UserFilter struct {
	predicateAdder
}

// Where applies the entql predicate on the query filter.
func (f *UserFilter) Where(p entql.P) {
	f.addPredicate(func(s *sql.Selector) {
		if err := schemaGraph.EvalP(schemaGraph.Nodes[8].Type, p, s); err != nil {
			s.AddError(err)
		}
	})
}

// WhereID applies the entql int predicate on the id field.
func (f *UserFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(user.FieldID))
}

// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
func (f *UserFilter) WhereCreatedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldCreatedAt))
}

// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
func (f *UserFilter) WhereUpdatedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldUpdatedAt))
}

// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field.
func (f *UserFilter) WhereDeletedAt(p entql.TimeP) {
	f.Where(p.Field(user.FieldDeletedAt))
}

// WhereUsername applies the entql string predicate on the username field.
func (f *UserFilter) WhereUsername(p entql.StringP) {
	f.Where(p.Field(user.FieldUsername))
}

// WhereDisplayName applies the entql string predicate on the display_name field.
func (f *UserFilter) WhereDisplayName(p entql.StringP) {
	f.Where(p.Field(user.FieldDisplayName))
}

// WhereURL applies the entql string predicate on the url field.
func (f *UserFilter) WhereURL(p entql.StringP) {
	f.Where(p.Field(user.FieldURL))
}

// WhereProvider applies the entql string predicate on the provider field.
func (f *UserFilter) WhereProvider(p entql.StringP) {
	f.Where(p.Field(user.FieldProvider))
}

// WhereProviderID applies the entql string predicate on the provider_id field.
func (f *UserFilter) WhereProviderID(p entql.StringP) {
	f.Where(p.Field(user.FieldProviderID))
}

// WhereProviderUsername applies the entql string predicate on the provider_username field.
func (f *UserFilter) WhereProviderUsername(p entql.StringP) {
	f.Where(p.Field(user.FieldProviderUsername))
}

// WhereProviderAvatar applies the entql string predicate on the provider_avatar field.
func (f *UserFilter) WhereProviderAvatar(p entql.StringP) {
	f.Where(p.Field(user.FieldProviderAvatar))
}

// WhereEmail applies the entql string predicate on the email field.
func (f *UserFilter) WhereEmail(p entql.StringP) {
	f.Where(p.Field(user.FieldEmail))
}

// WherePassword applies the entql string predicate on the password field.
func (f *UserFilter) WherePassword(p entql.StringP) {
	f.Where(p.Field(user.FieldPassword))
}

// WhereBio applies the entql string predicate on the bio field.
func (f *UserFilter) WhereBio(p entql.StringP) {
	f.Where(p.Field(user.FieldBio))
}

// WhereBioHTML applies the entql string predicate on the bio_html field.
func (f *UserFilter) WhereBioHTML(p entql.StringP) {
	f.Where(p.Field(user.FieldBioHTML))
}

// WhereActive applies the entql bool predicate on the active field.
func (f *UserFilter) WhereActive(p entql.BoolP) {
	f.Where(p.Field(user.FieldActive))
}

// WhereAvatarImageID applies the entql int predicate on the avatar_image_id field.
func (f *UserFilter) WhereAvatarImageID(p entql.IntP) {
	f.Where(p.Field(user.FieldAvatarImageID))
}

// WhereHasPosts applies a predicate to check if query has an edge posts.
func (f *UserFilter) WhereHasPosts() {
	f.Where(entql.HasEdge("posts"))
}

// WhereHasPostsWith applies a predicate to check if query has an edge posts with a given conditions (other predicates).
func (f *UserFilter) WhereHasPostsWith(preds ...predicate.Post) {
	f.Where(entql.HasEdgeWith("posts", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasFiles applies a predicate to check if query has an edge files.
func (f *UserFilter) WhereHasFiles() {
	f.Where(entql.HasEdge("files"))
}

// WhereHasFilesWith applies a predicate to check if query has an edge files with a given conditions (other predicates).
func (f *UserFilter) WhereHasFilesWith(preds ...predicate.File) {
	f.Where(entql.HasEdgeWith("files", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasComments applies a predicate to check if query has an edge comments.
func (f *UserFilter) WhereHasComments() {
	f.Where(entql.HasEdge("comments"))
}

// WhereHasCommentsWith applies a predicate to check if query has an edge comments with a given conditions (other predicates).
func (f *UserFilter) WhereHasCommentsWith(preds ...predicate.Comment) {
	f.Where(entql.HasEdgeWith("comments", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasRoles applies a predicate to check if query has an edge roles.
func (f *UserFilter) WhereHasRoles() {
	f.Where(entql.HasEdge("roles"))
}

// WhereHasRolesWith applies a predicate to check if query has an edge roles with a given conditions (other predicates).
func (f *UserFilter) WhereHasRolesWith(preds ...predicate.Role) {
	f.Where(entql.HasEdgeWith("roles", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasAvatarImage applies a predicate to check if query has an edge avatar_image.
func (f *UserFilter) WhereHasAvatarImage() {
	f.Where(entql.HasEdge("avatar_image"))
}

// WhereHasAvatarImageWith applies a predicate to check if query has an edge avatar_image with a given conditions (other predicates).
func (f *UserFilter) WhereHasAvatarImageWith(preds ...predicate.File) {
	f.Where(entql.HasEdgeWith("avatar_image", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}