// Copyright 2019-present Facebook Inc. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"entgo.io/ent/entc/integration/edgeschema/ent/attachedfile"
	"entgo.io/ent/entc/integration/edgeschema/ent/file"
	"entgo.io/ent/entc/integration/edgeschema/ent/friendship"
	"entgo.io/ent/entc/integration/edgeschema/ent/group"
	"entgo.io/ent/entc/integration/edgeschema/ent/grouptag"
	"entgo.io/ent/entc/integration/edgeschema/ent/predicate"
	"entgo.io/ent/entc/integration/edgeschema/ent/process"
	"entgo.io/ent/entc/integration/edgeschema/ent/relationship"
	"entgo.io/ent/entc/integration/edgeschema/ent/relationshipinfo"
	"entgo.io/ent/entc/integration/edgeschema/ent/role"
	"entgo.io/ent/entc/integration/edgeschema/ent/roleuser"
	"entgo.io/ent/entc/integration/edgeschema/ent/tag"
	"entgo.io/ent/entc/integration/edgeschema/ent/tweet"
	"entgo.io/ent/entc/integration/edgeschema/ent/tweetlike"
	"entgo.io/ent/entc/integration/edgeschema/ent/tweettag"
	"entgo.io/ent/entc/integration/edgeschema/ent/user"
	"entgo.io/ent/entc/integration/edgeschema/ent/usergroup"
	"entgo.io/ent/entc/integration/edgeschema/ent/usertweet"

	"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, 17)}
	graph.Nodes[0] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   attachedfile.Table,
			Columns: attachedfile.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: attachedfile.FieldID,
			},
		},
		Type: "AttachedFile",
		Fields: map[string]*sqlgraph.FieldSpec{
			attachedfile.FieldAttachTime: {Type: field.TypeTime, Column: attachedfile.FieldAttachTime},
			attachedfile.FieldFID:        {Type: field.TypeInt, Column: attachedfile.FieldFID},
			attachedfile.FieldProcID:     {Type: field.TypeInt, Column: attachedfile.FieldProcID},
		},
	}
	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.FieldName: {Type: field.TypeString, Column: file.FieldName},
		},
	}
	graph.Nodes[2] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   friendship.Table,
			Columns: friendship.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: friendship.FieldID,
			},
		},
		Type: "Friendship",
		Fields: map[string]*sqlgraph.FieldSpec{
			friendship.FieldWeight:    {Type: field.TypeInt, Column: friendship.FieldWeight},
			friendship.FieldCreatedAt: {Type: field.TypeTime, Column: friendship.FieldCreatedAt},
			friendship.FieldUserID:    {Type: field.TypeInt, Column: friendship.FieldUserID},
			friendship.FieldFriendID:  {Type: field.TypeInt, Column: friendship.FieldFriendID},
		},
	}
	graph.Nodes[3] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   group.Table,
			Columns: group.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: group.FieldID,
			},
		},
		Type: "Group",
		Fields: map[string]*sqlgraph.FieldSpec{
			group.FieldName: {Type: field.TypeString, Column: group.FieldName},
		},
	}
	graph.Nodes[4] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   grouptag.Table,
			Columns: grouptag.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: grouptag.FieldID,
			},
		},
		Type: "GroupTag",
		Fields: map[string]*sqlgraph.FieldSpec{
			grouptag.FieldTagID:   {Type: field.TypeInt, Column: grouptag.FieldTagID},
			grouptag.FieldGroupID: {Type: field.TypeInt, Column: grouptag.FieldGroupID},
		},
	}
	graph.Nodes[5] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   process.Table,
			Columns: process.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: process.FieldID,
			},
		},
		Type:   "Process",
		Fields: map[string]*sqlgraph.FieldSpec{},
	}
	graph.Nodes[6] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   relationship.Table,
			Columns: relationship.Columns,
			CompositeID: []*sqlgraph.FieldSpec{
				{
					Type:   field.TypeInt,
					Column: relationship.FieldUserID,
				},
				{
					Type:   field.TypeInt,
					Column: relationship.FieldRelativeID,
				},
			},
		},
		Type: "Relationship",
		Fields: map[string]*sqlgraph.FieldSpec{
			relationship.FieldWeight:     {Type: field.TypeInt, Column: relationship.FieldWeight},
			relationship.FieldUserID:     {Type: field.TypeInt, Column: relationship.FieldUserID},
			relationship.FieldRelativeID: {Type: field.TypeInt, Column: relationship.FieldRelativeID},
			relationship.FieldInfoID:     {Type: field.TypeInt, Column: relationship.FieldInfoID},
		},
	}
	graph.Nodes[7] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   relationshipinfo.Table,
			Columns: relationshipinfo.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: relationshipinfo.FieldID,
			},
		},
		Type: "RelationshipInfo",
		Fields: map[string]*sqlgraph.FieldSpec{
			relationshipinfo.FieldText: {Type: field.TypeString, Column: relationshipinfo.FieldText},
		},
	}
	graph.Nodes[8] = &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.FieldName:      {Type: field.TypeString, Column: role.FieldName},
			role.FieldCreatedAt: {Type: field.TypeTime, Column: role.FieldCreatedAt},
		},
	}
	graph.Nodes[9] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   roleuser.Table,
			Columns: roleuser.Columns,
			CompositeID: []*sqlgraph.FieldSpec{
				{
					Type:   field.TypeInt,
					Column: roleuser.FieldUserID,
				},
				{
					Type:   field.TypeInt,
					Column: roleuser.FieldRoleID,
				},
			},
		},
		Type: "RoleUser",
		Fields: map[string]*sqlgraph.FieldSpec{
			roleuser.FieldCreatedAt: {Type: field.TypeTime, Column: roleuser.FieldCreatedAt},
			roleuser.FieldRoleID:    {Type: field.TypeInt, Column: roleuser.FieldRoleID},
			roleuser.FieldUserID:    {Type: field.TypeInt, Column: roleuser.FieldUserID},
		},
	}
	graph.Nodes[10] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   tag.Table,
			Columns: tag.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: tag.FieldID,
			},
		},
		Type: "Tag",
		Fields: map[string]*sqlgraph.FieldSpec{
			tag.FieldValue: {Type: field.TypeString, Column: tag.FieldValue},
		},
	}
	graph.Nodes[11] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   tweet.Table,
			Columns: tweet.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: tweet.FieldID,
			},
		},
		Type: "Tweet",
		Fields: map[string]*sqlgraph.FieldSpec{
			tweet.FieldText: {Type: field.TypeString, Column: tweet.FieldText},
		},
	}
	graph.Nodes[12] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   tweetlike.Table,
			Columns: tweetlike.Columns,
			CompositeID: []*sqlgraph.FieldSpec{
				{
					Type:   field.TypeInt,
					Column: tweetlike.FieldUserID,
				},
				{
					Type:   field.TypeInt,
					Column: tweetlike.FieldTweetID,
				},
			},
		},
		Type: "TweetLike",
		Fields: map[string]*sqlgraph.FieldSpec{
			tweetlike.FieldLikedAt: {Type: field.TypeTime, Column: tweetlike.FieldLikedAt},
			tweetlike.FieldUserID:  {Type: field.TypeInt, Column: tweetlike.FieldUserID},
			tweetlike.FieldTweetID: {Type: field.TypeInt, Column: tweetlike.FieldTweetID},
		},
	}
	graph.Nodes[13] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   tweettag.Table,
			Columns: tweettag.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUUID,
				Column: tweettag.FieldID,
			},
		},
		Type: "TweetTag",
		Fields: map[string]*sqlgraph.FieldSpec{
			tweettag.FieldAddedAt: {Type: field.TypeTime, Column: tweettag.FieldAddedAt},
			tweettag.FieldTagID:   {Type: field.TypeInt, Column: tweettag.FieldTagID},
			tweettag.FieldTweetID: {Type: field.TypeInt, Column: tweettag.FieldTweetID},
		},
	}
	graph.Nodes[14] = &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.FieldName: {Type: field.TypeString, Column: user.FieldName},
		},
	}
	graph.Nodes[15] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   usergroup.Table,
			Columns: usergroup.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: usergroup.FieldID,
			},
		},
		Type: "UserGroup",
		Fields: map[string]*sqlgraph.FieldSpec{
			usergroup.FieldJoinedAt: {Type: field.TypeTime, Column: usergroup.FieldJoinedAt},
			usergroup.FieldUserID:   {Type: field.TypeInt, Column: usergroup.FieldUserID},
			usergroup.FieldGroupID:  {Type: field.TypeInt, Column: usergroup.FieldGroupID},
		},
	}
	graph.Nodes[16] = &sqlgraph.Node{
		NodeSpec: sqlgraph.NodeSpec{
			Table:   usertweet.Table,
			Columns: usertweet.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeInt,
				Column: usertweet.FieldID,
			},
		},
		Type: "UserTweet",
		Fields: map[string]*sqlgraph.FieldSpec{
			usertweet.FieldCreatedAt: {Type: field.TypeTime, Column: usertweet.FieldCreatedAt},
			usertweet.FieldUserID:    {Type: field.TypeInt, Column: usertweet.FieldUserID},
			usertweet.FieldTweetID:   {Type: field.TypeInt, Column: usertweet.FieldTweetID},
		},
	}
	graph.MustAddE(
		"fi",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   attachedfile.FiTable,
			Columns: []string{attachedfile.FiColumn},
			Bidi:    false,
		},
		"AttachedFile",
		"File",
	)
	graph.MustAddE(
		"proc",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   attachedfile.ProcTable,
			Columns: []string{attachedfile.ProcColumn},
			Bidi:    false,
		},
		"AttachedFile",
		"Process",
	)
	graph.MustAddE(
		"processes",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   file.ProcessesTable,
			Columns: file.ProcessesPrimaryKey,
			Bidi:    false,
		},
		"File",
		"Process",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   friendship.UserTable,
			Columns: []string{friendship.UserColumn},
			Bidi:    false,
		},
		"Friendship",
		"User",
	)
	graph.MustAddE(
		"friend",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   friendship.FriendTable,
			Columns: []string{friendship.FriendColumn},
			Bidi:    false,
		},
		"Friendship",
		"User",
	)
	graph.MustAddE(
		"users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   group.UsersTable,
			Columns: group.UsersPrimaryKey,
			Bidi:    false,
		},
		"Group",
		"User",
	)
	graph.MustAddE(
		"tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   group.TagsTable,
			Columns: group.TagsPrimaryKey,
			Bidi:    false,
		},
		"Group",
		"Tag",
	)
	graph.MustAddE(
		"joined_users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   group.JoinedUsersTable,
			Columns: []string{group.JoinedUsersColumn},
			Bidi:    false,
		},
		"Group",
		"UserGroup",
	)
	graph.MustAddE(
		"group_tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   group.GroupTagsTable,
			Columns: []string{group.GroupTagsColumn},
			Bidi:    false,
		},
		"Group",
		"GroupTag",
	)
	graph.MustAddE(
		"tag",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   grouptag.TagTable,
			Columns: []string{grouptag.TagColumn},
			Bidi:    false,
		},
		"GroupTag",
		"Tag",
	)
	graph.MustAddE(
		"group",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   grouptag.GroupTable,
			Columns: []string{grouptag.GroupColumn},
			Bidi:    false,
		},
		"GroupTag",
		"Group",
	)
	graph.MustAddE(
		"files",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   process.FilesTable,
			Columns: process.FilesPrimaryKey,
			Bidi:    false,
		},
		"Process",
		"File",
	)
	graph.MustAddE(
		"attached_files",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   process.AttachedFilesTable,
			Columns: []string{process.AttachedFilesColumn},
			Bidi:    false,
		},
		"Process",
		"AttachedFile",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   relationship.UserTable,
			Columns: []string{relationship.UserColumn},
			Bidi:    false,
		},
		"Relationship",
		"User",
	)
	graph.MustAddE(
		"relative",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   relationship.RelativeTable,
			Columns: []string{relationship.RelativeColumn},
			Bidi:    false,
		},
		"Relationship",
		"User",
	)
	graph.MustAddE(
		"info",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   relationship.InfoTable,
			Columns: []string{relationship.InfoColumn},
			Bidi:    false,
		},
		"Relationship",
		"RelationshipInfo",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   role.UserTable,
			Columns: role.UserPrimaryKey,
			Bidi:    false,
		},
		"Role",
		"User",
	)
	graph.MustAddE(
		"roles_users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   role.RolesUsersTable,
			Columns: []string{role.RolesUsersColumn},
			Bidi:    false,
		},
		"Role",
		"RoleUser",
	)
	graph.MustAddE(
		"role",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   roleuser.RoleTable,
			Columns: []string{roleuser.RoleColumn},
			Bidi:    false,
		},
		"RoleUser",
		"Role",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   roleuser.UserTable,
			Columns: []string{roleuser.UserColumn},
			Bidi:    false,
		},
		"RoleUser",
		"User",
	)
	graph.MustAddE(
		"tweets",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   tag.TweetsTable,
			Columns: tag.TweetsPrimaryKey,
			Bidi:    false,
		},
		"Tag",
		"Tweet",
	)
	graph.MustAddE(
		"groups",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   tag.GroupsTable,
			Columns: tag.GroupsPrimaryKey,
			Bidi:    false,
		},
		"Tag",
		"Group",
	)
	graph.MustAddE(
		"tweet_tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   tag.TweetTagsTable,
			Columns: []string{tag.TweetTagsColumn},
			Bidi:    false,
		},
		"Tag",
		"TweetTag",
	)
	graph.MustAddE(
		"group_tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   tag.GroupTagsTable,
			Columns: []string{tag.GroupTagsColumn},
			Bidi:    false,
		},
		"Tag",
		"GroupTag",
	)
	graph.MustAddE(
		"liked_users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   tweet.LikedUsersTable,
			Columns: tweet.LikedUsersPrimaryKey,
			Bidi:    false,
		},
		"Tweet",
		"User",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   tweet.UserTable,
			Columns: tweet.UserPrimaryKey,
			Bidi:    false,
		},
		"Tweet",
		"User",
	)
	graph.MustAddE(
		"tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: true,
			Table:   tweet.TagsTable,
			Columns: tweet.TagsPrimaryKey,
			Bidi:    false,
		},
		"Tweet",
		"Tag",
	)
	graph.MustAddE(
		"likes",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   tweet.LikesTable,
			Columns: []string{tweet.LikesColumn},
			Bidi:    false,
		},
		"Tweet",
		"TweetLike",
	)
	graph.MustAddE(
		"tweet_user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   tweet.TweetUserTable,
			Columns: []string{tweet.TweetUserColumn},
			Bidi:    false,
		},
		"Tweet",
		"UserTweet",
	)
	graph.MustAddE(
		"tweet_tags",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   tweet.TweetTagsTable,
			Columns: []string{tweet.TweetTagsColumn},
			Bidi:    false,
		},
		"Tweet",
		"TweetTag",
	)
	graph.MustAddE(
		"tweet",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   tweetlike.TweetTable,
			Columns: []string{tweetlike.TweetColumn},
			Bidi:    false,
		},
		"TweetLike",
		"Tweet",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   tweetlike.UserTable,
			Columns: []string{tweetlike.UserColumn},
			Bidi:    false,
		},
		"TweetLike",
		"User",
	)
	graph.MustAddE(
		"tag",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   tweettag.TagTable,
			Columns: []string{tweettag.TagColumn},
			Bidi:    false,
		},
		"TweetTag",
		"Tag",
	)
	graph.MustAddE(
		"tweet",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   tweettag.TweetTable,
			Columns: []string{tweettag.TweetColumn},
			Bidi:    false,
		},
		"TweetTag",
		"Tweet",
	)
	graph.MustAddE(
		"groups",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.GroupsTable,
			Columns: user.GroupsPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Group",
	)
	graph.MustAddE(
		"friends",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.FriendsTable,
			Columns: user.FriendsPrimaryKey,
			Bidi:    true,
		},
		"User",
		"User",
	)
	graph.MustAddE(
		"relatives",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.RelativesTable,
			Columns: user.RelativesPrimaryKey,
			Bidi:    true,
		},
		"User",
		"User",
	)
	graph.MustAddE(
		"liked_tweets",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.LikedTweetsTable,
			Columns: user.LikedTweetsPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Tweet",
	)
	graph.MustAddE(
		"tweets",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.TweetsTable,
			Columns: user.TweetsPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Tweet",
	)
	graph.MustAddE(
		"roles",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2M,
			Inverse: false,
			Table:   user.RolesTable,
			Columns: user.RolesPrimaryKey,
			Bidi:    false,
		},
		"User",
		"Role",
	)
	graph.MustAddE(
		"joined_groups",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.JoinedGroupsTable,
			Columns: []string{user.JoinedGroupsColumn},
			Bidi:    false,
		},
		"User",
		"UserGroup",
	)
	graph.MustAddE(
		"friendships",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.FriendshipsTable,
			Columns: []string{user.FriendshipsColumn},
			Bidi:    false,
		},
		"User",
		"Friendship",
	)
	graph.MustAddE(
		"relationship",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.RelationshipTable,
			Columns: []string{user.RelationshipColumn},
			Bidi:    false,
		},
		"User",
		"Relationship",
	)
	graph.MustAddE(
		"likes",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.LikesTable,
			Columns: []string{user.LikesColumn},
			Bidi:    false,
		},
		"User",
		"TweetLike",
	)
	graph.MustAddE(
		"user_tweets",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.UserTweetsTable,
			Columns: []string{user.UserTweetsColumn},
			Bidi:    false,
		},
		"User",
		"UserTweet",
	)
	graph.MustAddE(
		"roles_users",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: true,
			Table:   user.RolesUsersTable,
			Columns: []string{user.RolesUsersColumn},
			Bidi:    false,
		},
		"User",
		"RoleUser",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   usergroup.UserTable,
			Columns: []string{usergroup.UserColumn},
			Bidi:    false,
		},
		"UserGroup",
		"User",
	)
	graph.MustAddE(
		"group",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   usergroup.GroupTable,
			Columns: []string{usergroup.GroupColumn},
			Bidi:    false,
		},
		"UserGroup",
		"Group",
	)
	graph.MustAddE(
		"user",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   usertweet.UserTable,
			Columns: []string{usertweet.UserColumn},
			Bidi:    false,
		},
		"UserTweet",
		"User",
	)
	graph.MustAddE(
		"tweet",
		&sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: false,
			Table:   usertweet.TweetTable,
			Columns: []string{usertweet.TweetColumn},
			Bidi:    false,
		},
		"UserTweet",
		"Tweet",
	)
	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 (_q *AttachedFileQuery) addPredicate(pred func(s *sql.Selector)) {
	_q.predicates = append(_q.predicates, pred)
}

// Filter returns a Filter implementation to apply filters on the AttachedFileQuery builder.
func (_q *AttachedFileQuery) Filter() *AttachedFileFilter {
	return &AttachedFileFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *AttachedFileMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the AttachedFileMutation builder.
func (m *AttachedFileMutation) Filter() *AttachedFileFilter {
	return &AttachedFileFilter{config: m.config, predicateAdder: m}
}

// AttachedFileFilter provides a generic filtering capability at runtime for AttachedFileQuery.
type AttachedFileFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *AttachedFileFilter) 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 *AttachedFileFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(attachedfile.FieldID))
}

// WhereAttachTime applies the entql time.Time predicate on the attach_time field.
func (f *AttachedFileFilter) WhereAttachTime(p entql.TimeP) {
	f.Where(p.Field(attachedfile.FieldAttachTime))
}

// WhereFID applies the entql int predicate on the f_id field.
func (f *AttachedFileFilter) WhereFID(p entql.IntP) {
	f.Where(p.Field(attachedfile.FieldFID))
}

// WhereProcID applies the entql int predicate on the proc_id field.
func (f *AttachedFileFilter) WhereProcID(p entql.IntP) {
	f.Where(p.Field(attachedfile.FieldProcID))
}

// WhereHasFi applies a predicate to check if query has an edge fi.
func (f *AttachedFileFilter) WhereHasFi() {
	f.Where(entql.HasEdge("fi"))
}

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

// WhereHasProc applies a predicate to check if query has an edge proc.
func (f *AttachedFileFilter) WhereHasProc() {
	f.Where(entql.HasEdge("proc"))
}

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

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

// Filter returns a Filter implementation to apply filters on the FileQuery builder.
func (_q *FileQuery) Filter() *FileFilter {
	return &FileFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *FileMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

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

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

// 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))
}

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

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

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

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

// Filter returns a Filter implementation to apply filters on the FriendshipQuery builder.
func (_q *FriendshipQuery) Filter() *FriendshipFilter {
	return &FriendshipFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *FriendshipMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the FriendshipMutation builder.
func (m *FriendshipMutation) Filter() *FriendshipFilter {
	return &FriendshipFilter{config: m.config, predicateAdder: m}
}

// FriendshipFilter provides a generic filtering capability at runtime for FriendshipQuery.
type FriendshipFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *FriendshipFilter) 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 *FriendshipFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(friendship.FieldID))
}

// WhereWeight applies the entql int predicate on the weight field.
func (f *FriendshipFilter) WhereWeight(p entql.IntP) {
	f.Where(p.Field(friendship.FieldWeight))
}

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

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

// WhereFriendID applies the entql int predicate on the friend_id field.
func (f *FriendshipFilter) WhereFriendID(p entql.IntP) {
	f.Where(p.Field(friendship.FieldFriendID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *FriendshipFilter) 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 *FriendshipFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasFriend applies a predicate to check if query has an edge friend.
func (f *FriendshipFilter) WhereHasFriend() {
	f.Where(entql.HasEdge("friend"))
}

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

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

// Filter returns a Filter implementation to apply filters on the GroupQuery builder.
func (_q *GroupQuery) Filter() *GroupFilter {
	return &GroupFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *GroupMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the GroupMutation builder.
func (m *GroupMutation) Filter() *GroupFilter {
	return &GroupFilter{config: m.config, predicateAdder: m}
}

// GroupFilter provides a generic filtering capability at runtime for GroupQuery.
type GroupFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *GroupFilter) 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 *GroupFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(group.FieldID))
}

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

// WhereHasUsers applies a predicate to check if query has an edge users.
func (f *GroupFilter) 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 *GroupFilter) WhereHasUsersWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("users", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasTags applies a predicate to check if query has an edge tags.
func (f *GroupFilter) WhereHasTags() {
	f.Where(entql.HasEdge("tags"))
}

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

// WhereHasJoinedUsers applies a predicate to check if query has an edge joined_users.
func (f *GroupFilter) WhereHasJoinedUsers() {
	f.Where(entql.HasEdge("joined_users"))
}

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

// WhereHasGroupTags applies a predicate to check if query has an edge group_tags.
func (f *GroupFilter) WhereHasGroupTags() {
	f.Where(entql.HasEdge("group_tags"))
}

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

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

// Filter returns a Filter implementation to apply filters on the GroupTagQuery builder.
func (_q *GroupTagQuery) Filter() *GroupTagFilter {
	return &GroupTagFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *GroupTagMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the GroupTagMutation builder.
func (m *GroupTagMutation) Filter() *GroupTagFilter {
	return &GroupTagFilter{config: m.config, predicateAdder: m}
}

// GroupTagFilter provides a generic filtering capability at runtime for GroupTagQuery.
type GroupTagFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *GroupTagFilter) 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 *GroupTagFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(grouptag.FieldID))
}

// WhereTagID applies the entql int predicate on the tag_id field.
func (f *GroupTagFilter) WhereTagID(p entql.IntP) {
	f.Where(p.Field(grouptag.FieldTagID))
}

// WhereGroupID applies the entql int predicate on the group_id field.
func (f *GroupTagFilter) WhereGroupID(p entql.IntP) {
	f.Where(p.Field(grouptag.FieldGroupID))
}

// WhereHasTag applies a predicate to check if query has an edge tag.
func (f *GroupTagFilter) WhereHasTag() {
	f.Where(entql.HasEdge("tag"))
}

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

// WhereHasGroup applies a predicate to check if query has an edge group.
func (f *GroupTagFilter) WhereHasGroup() {
	f.Where(entql.HasEdge("group"))
}

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

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

// Filter returns a Filter implementation to apply filters on the ProcessQuery builder.
func (_q *ProcessQuery) Filter() *ProcessFilter {
	return &ProcessFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *ProcessMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the ProcessMutation builder.
func (m *ProcessMutation) Filter() *ProcessFilter {
	return &ProcessFilter{config: m.config, predicateAdder: m}
}

// ProcessFilter provides a generic filtering capability at runtime for ProcessQuery.
type ProcessFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *ProcessFilter) 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 *ProcessFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(process.FieldID))
}

// WhereHasFiles applies a predicate to check if query has an edge files.
func (f *ProcessFilter) 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 *ProcessFilter) WhereHasFilesWith(preds ...predicate.File) {
	f.Where(entql.HasEdgeWith("files", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasAttachedFiles applies a predicate to check if query has an edge attached_files.
func (f *ProcessFilter) WhereHasAttachedFiles() {
	f.Where(entql.HasEdge("attached_files"))
}

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

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

// Filter returns a Filter implementation to apply filters on the RelationshipQuery builder.
func (_q *RelationshipQuery) Filter() *RelationshipFilter {
	return &RelationshipFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *RelationshipMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the RelationshipMutation builder.
func (m *RelationshipMutation) Filter() *RelationshipFilter {
	return &RelationshipFilter{config: m.config, predicateAdder: m}
}

// RelationshipFilter provides a generic filtering capability at runtime for RelationshipQuery.
type RelationshipFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *RelationshipFilter) 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)
		}
	})
}

// WhereWeight applies the entql int predicate on the weight field.
func (f *RelationshipFilter) WhereWeight(p entql.IntP) {
	f.Where(p.Field(relationship.FieldWeight))
}

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

// WhereRelativeID applies the entql int predicate on the relative_id field.
func (f *RelationshipFilter) WhereRelativeID(p entql.IntP) {
	f.Where(p.Field(relationship.FieldRelativeID))
}

// WhereInfoID applies the entql int predicate on the info_id field.
func (f *RelationshipFilter) WhereInfoID(p entql.IntP) {
	f.Where(p.Field(relationship.FieldInfoID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *RelationshipFilter) 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 *RelationshipFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasRelative applies a predicate to check if query has an edge relative.
func (f *RelationshipFilter) WhereHasRelative() {
	f.Where(entql.HasEdge("relative"))
}

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

// WhereHasInfo applies a predicate to check if query has an edge info.
func (f *RelationshipFilter) WhereHasInfo() {
	f.Where(entql.HasEdge("info"))
}

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

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

// Filter returns a Filter implementation to apply filters on the RelationshipInfoQuery builder.
func (_q *RelationshipInfoQuery) Filter() *RelationshipInfoFilter {
	return &RelationshipInfoFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *RelationshipInfoMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the RelationshipInfoMutation builder.
func (m *RelationshipInfoMutation) Filter() *RelationshipInfoFilter {
	return &RelationshipInfoFilter{config: m.config, predicateAdder: m}
}

// RelationshipInfoFilter provides a generic filtering capability at runtime for RelationshipInfoQuery.
type RelationshipInfoFilter struct {
	predicateAdder
	config
}

// Where applies the entql predicate on the query filter.
func (f *RelationshipInfoFilter) 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 *RelationshipInfoFilter) WhereID(p entql.IntP) {
	f.Where(p.Field(relationshipinfo.FieldID))
}

// WhereText applies the entql string predicate on the text field.
func (f *RelationshipInfoFilter) WhereText(p entql.StringP) {
	f.Where(p.Field(relationshipinfo.FieldText))
}

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

// Filter returns a Filter implementation to apply filters on the RoleQuery builder.
func (_q *RoleQuery) Filter() *RoleFilter {
	return &RoleFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *RoleMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

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

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

// 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[8].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))
}

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

// 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))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *RoleFilter) 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 *RoleFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

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

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

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

// Filter returns a Filter implementation to apply filters on the RoleUserQuery builder.
func (_q *RoleUserQuery) Filter() *RoleUserFilter {
	return &RoleUserFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *RoleUserMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the RoleUserMutation builder.
func (m *RoleUserMutation) Filter() *RoleUserFilter {
	return &RoleUserFilter{config: m.config, predicateAdder: m}
}

// RoleUserFilter provides a generic filtering capability at runtime for RoleUserQuery.
type RoleUserFilter struct {
	predicateAdder
	config
}

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

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

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

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

// WhereHasRole applies a predicate to check if query has an edge role.
func (f *RoleUserFilter) 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 *RoleUserFilter) WhereHasRoleWith(preds ...predicate.Role) {
	f.Where(entql.HasEdgeWith("role", 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 *RoleUserFilter) 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 *RoleUserFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

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

// Filter returns a Filter implementation to apply filters on the TagQuery builder.
func (_q *TagQuery) Filter() *TagFilter {
	return &TagFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *TagMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the TagMutation builder.
func (m *TagMutation) Filter() *TagFilter {
	return &TagFilter{config: m.config, predicateAdder: m}
}

// TagFilter provides a generic filtering capability at runtime for TagQuery.
type TagFilter struct {
	predicateAdder
	config
}

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

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

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

// WhereHasTweets applies a predicate to check if query has an edge tweets.
func (f *TagFilter) WhereHasTweets() {
	f.Where(entql.HasEdge("tweets"))
}

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

// WhereHasGroups applies a predicate to check if query has an edge groups.
func (f *TagFilter) WhereHasGroups() {
	f.Where(entql.HasEdge("groups"))
}

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

// WhereHasTweetTags applies a predicate to check if query has an edge tweet_tags.
func (f *TagFilter) WhereHasTweetTags() {
	f.Where(entql.HasEdge("tweet_tags"))
}

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

// WhereHasGroupTags applies a predicate to check if query has an edge group_tags.
func (f *TagFilter) WhereHasGroupTags() {
	f.Where(entql.HasEdge("group_tags"))
}

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

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

// Filter returns a Filter implementation to apply filters on the TweetQuery builder.
func (_q *TweetQuery) Filter() *TweetFilter {
	return &TweetFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *TweetMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the TweetMutation builder.
func (m *TweetMutation) Filter() *TweetFilter {
	return &TweetFilter{config: m.config, predicateAdder: m}
}

// TweetFilter provides a generic filtering capability at runtime for TweetQuery.
type TweetFilter struct {
	predicateAdder
	config
}

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

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

// WhereText applies the entql string predicate on the text field.
func (f *TweetFilter) WhereText(p entql.StringP) {
	f.Where(p.Field(tweet.FieldText))
}

// WhereHasLikedUsers applies a predicate to check if query has an edge liked_users.
func (f *TweetFilter) WhereHasLikedUsers() {
	f.Where(entql.HasEdge("liked_users"))
}

// WhereHasLikedUsersWith applies a predicate to check if query has an edge liked_users with a given conditions (other predicates).
func (f *TweetFilter) WhereHasLikedUsersWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("liked_users", 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 *TweetFilter) 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 *TweetFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasTags applies a predicate to check if query has an edge tags.
func (f *TweetFilter) WhereHasTags() {
	f.Where(entql.HasEdge("tags"))
}

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

// WhereHasLikes applies a predicate to check if query has an edge likes.
func (f *TweetFilter) WhereHasLikes() {
	f.Where(entql.HasEdge("likes"))
}

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

// WhereHasTweetUser applies a predicate to check if query has an edge tweet_user.
func (f *TweetFilter) WhereHasTweetUser() {
	f.Where(entql.HasEdge("tweet_user"))
}

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

// WhereHasTweetTags applies a predicate to check if query has an edge tweet_tags.
func (f *TweetFilter) WhereHasTweetTags() {
	f.Where(entql.HasEdge("tweet_tags"))
}

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

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

// Filter returns a Filter implementation to apply filters on the TweetLikeQuery builder.
func (_q *TweetLikeQuery) Filter() *TweetLikeFilter {
	return &TweetLikeFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *TweetLikeMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the TweetLikeMutation builder.
func (m *TweetLikeMutation) Filter() *TweetLikeFilter {
	return &TweetLikeFilter{config: m.config, predicateAdder: m}
}

// TweetLikeFilter provides a generic filtering capability at runtime for TweetLikeQuery.
type TweetLikeFilter struct {
	predicateAdder
	config
}

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

// WhereLikedAt applies the entql time.Time predicate on the liked_at field.
func (f *TweetLikeFilter) WhereLikedAt(p entql.TimeP) {
	f.Where(p.Field(tweetlike.FieldLikedAt))
}

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

// WhereTweetID applies the entql int predicate on the tweet_id field.
func (f *TweetLikeFilter) WhereTweetID(p entql.IntP) {
	f.Where(p.Field(tweetlike.FieldTweetID))
}

// WhereHasTweet applies a predicate to check if query has an edge tweet.
func (f *TweetLikeFilter) WhereHasTweet() {
	f.Where(entql.HasEdge("tweet"))
}

// WhereHasTweetWith applies a predicate to check if query has an edge tweet with a given conditions (other predicates).
func (f *TweetLikeFilter) WhereHasTweetWith(preds ...predicate.Tweet) {
	f.Where(entql.HasEdgeWith("tweet", 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 *TweetLikeFilter) 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 *TweetLikeFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

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

// Filter returns a Filter implementation to apply filters on the TweetTagQuery builder.
func (_q *TweetTagQuery) Filter() *TweetTagFilter {
	return &TweetTagFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *TweetTagMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the TweetTagMutation builder.
func (m *TweetTagMutation) Filter() *TweetTagFilter {
	return &TweetTagFilter{config: m.config, predicateAdder: m}
}

// TweetTagFilter provides a generic filtering capability at runtime for TweetTagQuery.
type TweetTagFilter struct {
	predicateAdder
	config
}

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

// WhereID applies the entql [16]byte predicate on the id field.
func (f *TweetTagFilter) WhereID(p entql.ValueP) {
	f.Where(p.Field(tweettag.FieldID))
}

// WhereAddedAt applies the entql time.Time predicate on the added_at field.
func (f *TweetTagFilter) WhereAddedAt(p entql.TimeP) {
	f.Where(p.Field(tweettag.FieldAddedAt))
}

// WhereTagID applies the entql int predicate on the tag_id field.
func (f *TweetTagFilter) WhereTagID(p entql.IntP) {
	f.Where(p.Field(tweettag.FieldTagID))
}

// WhereTweetID applies the entql int predicate on the tweet_id field.
func (f *TweetTagFilter) WhereTweetID(p entql.IntP) {
	f.Where(p.Field(tweettag.FieldTweetID))
}

// WhereHasTag applies a predicate to check if query has an edge tag.
func (f *TweetTagFilter) WhereHasTag() {
	f.Where(entql.HasEdge("tag"))
}

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

// WhereHasTweet applies a predicate to check if query has an edge tweet.
func (f *TweetTagFilter) WhereHasTweet() {
	f.Where(entql.HasEdge("tweet"))
}

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

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

// Filter returns a Filter implementation to apply filters on the UserQuery builder.
func (_q *UserQuery) Filter() *UserFilter {
	return &UserFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *UserMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

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

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

// 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[14].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))
}

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

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

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

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

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

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

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

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

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

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

// WhereHasTweetsWith applies a predicate to check if query has an edge tweets with a given conditions (other predicates).
func (f *UserFilter) WhereHasTweetsWith(preds ...predicate.Tweet) {
	f.Where(entql.HasEdgeWith("tweets", 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)
		}
	})))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Filter returns a Filter implementation to apply filters on the UserGroupQuery builder.
func (_q *UserGroupQuery) Filter() *UserGroupFilter {
	return &UserGroupFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *UserGroupMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the UserGroupMutation builder.
func (m *UserGroupMutation) Filter() *UserGroupFilter {
	return &UserGroupFilter{config: m.config, predicateAdder: m}
}

// UserGroupFilter provides a generic filtering capability at runtime for UserGroupQuery.
type UserGroupFilter struct {
	predicateAdder
	config
}

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

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

// WhereJoinedAt applies the entql time.Time predicate on the joined_at field.
func (f *UserGroupFilter) WhereJoinedAt(p entql.TimeP) {
	f.Where(p.Field(usergroup.FieldJoinedAt))
}

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

// WhereGroupID applies the entql int predicate on the group_id field.
func (f *UserGroupFilter) WhereGroupID(p entql.IntP) {
	f.Where(p.Field(usergroup.FieldGroupID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *UserGroupFilter) 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 *UserGroupFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasGroup applies a predicate to check if query has an edge group.
func (f *UserGroupFilter) WhereHasGroup() {
	f.Where(entql.HasEdge("group"))
}

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

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

// Filter returns a Filter implementation to apply filters on the UserTweetQuery builder.
func (_q *UserTweetQuery) Filter() *UserTweetFilter {
	return &UserTweetFilter{config: _q.config, predicateAdder: _q}
}

// addPredicate implements the predicateAdder interface.
func (m *UserTweetMutation) addPredicate(pred func(s *sql.Selector)) {
	m.Where(pred)
}

// Filter returns an entql.Where implementation to apply filters on the UserTweetMutation builder.
func (m *UserTweetMutation) Filter() *UserTweetFilter {
	return &UserTweetFilter{config: m.config, predicateAdder: m}
}

// UserTweetFilter provides a generic filtering capability at runtime for UserTweetQuery.
type UserTweetFilter struct {
	predicateAdder
	config
}

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

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

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

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

// WhereTweetID applies the entql int predicate on the tweet_id field.
func (f *UserTweetFilter) WhereTweetID(p entql.IntP) {
	f.Where(p.Field(usertweet.FieldTweetID))
}

// WhereHasUser applies a predicate to check if query has an edge user.
func (f *UserTweetFilter) 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 *UserTweetFilter) WhereHasUserWith(preds ...predicate.User) {
	f.Where(entql.HasEdgeWith("user", sqlgraph.WrapFunc(func(s *sql.Selector) {
		for _, p := range preds {
			p(s)
		}
	})))
}

// WhereHasTweet applies a predicate to check if query has an edge tweet.
func (f *UserTweetFilter) WhereHasTweet() {
	f.Where(entql.HasEdge("tweet"))
}

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