gql_where_input.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"errors"
	"fmt"
	"time"

	"github.com/fogo-sh/grackdb/ent/discordaccount"
	"github.com/fogo-sh/grackdb/ent/discordbot"
	"github.com/fogo-sh/grackdb/ent/githubaccount"
	"github.com/fogo-sh/grackdb/ent/githuborganization"
	"github.com/fogo-sh/grackdb/ent/githuborganizationmember"
	"github.com/fogo-sh/grackdb/ent/predicate"
	"github.com/fogo-sh/grackdb/ent/project"
	"github.com/fogo-sh/grackdb/ent/projectassociation"
	"github.com/fogo-sh/grackdb/ent/projectcontributor"
	"github.com/fogo-sh/grackdb/ent/projecttechnology"
	"github.com/fogo-sh/grackdb/ent/repository"
	"github.com/fogo-sh/grackdb/ent/repositorytechnology"
	"github.com/fogo-sh/grackdb/ent/site"
	"github.com/fogo-sh/grackdb/ent/technology"
	"github.com/fogo-sh/grackdb/ent/technologyassociation"
	"github.com/fogo-sh/grackdb/ent/user"
)

// DiscordAccountWhereInput represents a where input for filtering DiscordAccount queries.
type DiscordAccountWhereInput struct {
	Predicates []predicate.DiscordAccount  `json:"-"`
	Not        *DiscordAccountWhereInput   `json:"not,omitempty"`
	Or         []*DiscordAccountWhereInput `json:"or,omitempty"`
	And        []*DiscordAccountWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "discord_id" field predicates.
	DiscordID             *string  `json:"discordID,omitempty"`
	DiscordIDNEQ          *string  `json:"discordIDNEQ,omitempty"`
	DiscordIDIn           []string `json:"discordIDIn,omitempty"`
	DiscordIDNotIn        []string `json:"discordIDNotIn,omitempty"`
	DiscordIDGT           *string  `json:"discordIDGT,omitempty"`
	DiscordIDGTE          *string  `json:"discordIDGTE,omitempty"`
	DiscordIDLT           *string  `json:"discordIDLT,omitempty"`
	DiscordIDLTE          *string  `json:"discordIDLTE,omitempty"`
	DiscordIDContains     *string  `json:"discordIDContains,omitempty"`
	DiscordIDHasPrefix    *string  `json:"discordIDHasPrefix,omitempty"`
	DiscordIDHasSuffix    *string  `json:"discordIDHasSuffix,omitempty"`
	DiscordIDEqualFold    *string  `json:"discordIDEqualFold,omitempty"`
	DiscordIDContainsFold *string  `json:"discordIDContainsFold,omitempty"`

	// "username" field predicates.
	Username             *string  `json:"username,omitempty"`
	UsernameNEQ          *string  `json:"usernameNEQ,omitempty"`
	UsernameIn           []string `json:"usernameIn,omitempty"`
	UsernameNotIn        []string `json:"usernameNotIn,omitempty"`
	UsernameGT           *string  `json:"usernameGT,omitempty"`
	UsernameGTE          *string  `json:"usernameGTE,omitempty"`
	UsernameLT           *string  `json:"usernameLT,omitempty"`
	UsernameLTE          *string  `json:"usernameLTE,omitempty"`
	UsernameContains     *string  `json:"usernameContains,omitempty"`
	UsernameHasPrefix    *string  `json:"usernameHasPrefix,omitempty"`
	UsernameHasSuffix    *string  `json:"usernameHasSuffix,omitempty"`
	UsernameEqualFold    *string  `json:"usernameEqualFold,omitempty"`
	UsernameContainsFold *string  `json:"usernameContainsFold,omitempty"`

	// "discriminator" field predicates.
	Discriminator             *string  `json:"discriminator,omitempty"`
	DiscriminatorNEQ          *string  `json:"discriminatorNEQ,omitempty"`
	DiscriminatorIn           []string `json:"discriminatorIn,omitempty"`
	DiscriminatorNotIn        []string `json:"discriminatorNotIn,omitempty"`
	DiscriminatorGT           *string  `json:"discriminatorGT,omitempty"`
	DiscriminatorGTE          *string  `json:"discriminatorGTE,omitempty"`
	DiscriminatorLT           *string  `json:"discriminatorLT,omitempty"`
	DiscriminatorLTE          *string  `json:"discriminatorLTE,omitempty"`
	DiscriminatorContains     *string  `json:"discriminatorContains,omitempty"`
	DiscriminatorHasPrefix    *string  `json:"discriminatorHasPrefix,omitempty"`
	DiscriminatorHasSuffix    *string  `json:"discriminatorHasSuffix,omitempty"`
	DiscriminatorEqualFold    *string  `json:"discriminatorEqualFold,omitempty"`
	DiscriminatorContainsFold *string  `json:"discriminatorContainsFold,omitempty"`

	// "owner" edge predicates.
	HasOwner     *bool             `json:"hasOwner,omitempty"`
	HasOwnerWith []*UserWhereInput `json:"hasOwnerWith,omitempty"`

	// "bot" edge predicates.
	HasBot     *bool                   `json:"hasBot,omitempty"`
	HasBotWith []*DiscordBotWhereInput `json:"hasBotWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *DiscordAccountWhereInput) AddPredicates(predicates ...predicate.DiscordAccount) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the DiscordAccountWhereInput filter on the DiscordAccountQuery builder.
func (i *DiscordAccountWhereInput) Filter(q *DiscordAccountQuery) (*DiscordAccountQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyDiscordAccountWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyDiscordAccountWhereInput is returned in case the DiscordAccountWhereInput is empty.
var ErrEmptyDiscordAccountWhereInput = errors.New("ent: empty predicate DiscordAccountWhereInput")

// P returns a predicate for filtering discordaccounts.
// An error is returned if the input is empty or invalid.
func (i *DiscordAccountWhereInput) P() (predicate.DiscordAccount, error) {
	var predicates []predicate.DiscordAccount
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, discordaccount.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.DiscordAccount, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, discordaccount.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.DiscordAccount, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, discordaccount.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, discordaccount.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, discordaccount.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, discordaccount.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, discordaccount.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, discordaccount.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, discordaccount.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, discordaccount.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, discordaccount.IDLTE(*i.IDLTE))
	}
	if i.DiscordID != nil {
		predicates = append(predicates, discordaccount.DiscordIDEQ(*i.DiscordID))
	}
	if i.DiscordIDNEQ != nil {
		predicates = append(predicates, discordaccount.DiscordIDNEQ(*i.DiscordIDNEQ))
	}
	if len(i.DiscordIDIn) > 0 {
		predicates = append(predicates, discordaccount.DiscordIDIn(i.DiscordIDIn...))
	}
	if len(i.DiscordIDNotIn) > 0 {
		predicates = append(predicates, discordaccount.DiscordIDNotIn(i.DiscordIDNotIn...))
	}
	if i.DiscordIDGT != nil {
		predicates = append(predicates, discordaccount.DiscordIDGT(*i.DiscordIDGT))
	}
	if i.DiscordIDGTE != nil {
		predicates = append(predicates, discordaccount.DiscordIDGTE(*i.DiscordIDGTE))
	}
	if i.DiscordIDLT != nil {
		predicates = append(predicates, discordaccount.DiscordIDLT(*i.DiscordIDLT))
	}
	if i.DiscordIDLTE != nil {
		predicates = append(predicates, discordaccount.DiscordIDLTE(*i.DiscordIDLTE))
	}
	if i.DiscordIDContains != nil {
		predicates = append(predicates, discordaccount.DiscordIDContains(*i.DiscordIDContains))
	}
	if i.DiscordIDHasPrefix != nil {
		predicates = append(predicates, discordaccount.DiscordIDHasPrefix(*i.DiscordIDHasPrefix))
	}
	if i.DiscordIDHasSuffix != nil {
		predicates = append(predicates, discordaccount.DiscordIDHasSuffix(*i.DiscordIDHasSuffix))
	}
	if i.DiscordIDEqualFold != nil {
		predicates = append(predicates, discordaccount.DiscordIDEqualFold(*i.DiscordIDEqualFold))
	}
	if i.DiscordIDContainsFold != nil {
		predicates = append(predicates, discordaccount.DiscordIDContainsFold(*i.DiscordIDContainsFold))
	}
	if i.Username != nil {
		predicates = append(predicates, discordaccount.UsernameEQ(*i.Username))
	}
	if i.UsernameNEQ != nil {
		predicates = append(predicates, discordaccount.UsernameNEQ(*i.UsernameNEQ))
	}
	if len(i.UsernameIn) > 0 {
		predicates = append(predicates, discordaccount.UsernameIn(i.UsernameIn...))
	}
	if len(i.UsernameNotIn) > 0 {
		predicates = append(predicates, discordaccount.UsernameNotIn(i.UsernameNotIn...))
	}
	if i.UsernameGT != nil {
		predicates = append(predicates, discordaccount.UsernameGT(*i.UsernameGT))
	}
	if i.UsernameGTE != nil {
		predicates = append(predicates, discordaccount.UsernameGTE(*i.UsernameGTE))
	}
	if i.UsernameLT != nil {
		predicates = append(predicates, discordaccount.UsernameLT(*i.UsernameLT))
	}
	if i.UsernameLTE != nil {
		predicates = append(predicates, discordaccount.UsernameLTE(*i.UsernameLTE))
	}
	if i.UsernameContains != nil {
		predicates = append(predicates, discordaccount.UsernameContains(*i.UsernameContains))
	}
	if i.UsernameHasPrefix != nil {
		predicates = append(predicates, discordaccount.UsernameHasPrefix(*i.UsernameHasPrefix))
	}
	if i.UsernameHasSuffix != nil {
		predicates = append(predicates, discordaccount.UsernameHasSuffix(*i.UsernameHasSuffix))
	}
	if i.UsernameEqualFold != nil {
		predicates = append(predicates, discordaccount.UsernameEqualFold(*i.UsernameEqualFold))
	}
	if i.UsernameContainsFold != nil {
		predicates = append(predicates, discordaccount.UsernameContainsFold(*i.UsernameContainsFold))
	}
	if i.Discriminator != nil {
		predicates = append(predicates, discordaccount.DiscriminatorEQ(*i.Discriminator))
	}
	if i.DiscriminatorNEQ != nil {
		predicates = append(predicates, discordaccount.DiscriminatorNEQ(*i.DiscriminatorNEQ))
	}
	if len(i.DiscriminatorIn) > 0 {
		predicates = append(predicates, discordaccount.DiscriminatorIn(i.DiscriminatorIn...))
	}
	if len(i.DiscriminatorNotIn) > 0 {
		predicates = append(predicates, discordaccount.DiscriminatorNotIn(i.DiscriminatorNotIn...))
	}
	if i.DiscriminatorGT != nil {
		predicates = append(predicates, discordaccount.DiscriminatorGT(*i.DiscriminatorGT))
	}
	if i.DiscriminatorGTE != nil {
		predicates = append(predicates, discordaccount.DiscriminatorGTE(*i.DiscriminatorGTE))
	}
	if i.DiscriminatorLT != nil {
		predicates = append(predicates, discordaccount.DiscriminatorLT(*i.DiscriminatorLT))
	}
	if i.DiscriminatorLTE != nil {
		predicates = append(predicates, discordaccount.DiscriminatorLTE(*i.DiscriminatorLTE))
	}
	if i.DiscriminatorContains != nil {
		predicates = append(predicates, discordaccount.DiscriminatorContains(*i.DiscriminatorContains))
	}
	if i.DiscriminatorHasPrefix != nil {
		predicates = append(predicates, discordaccount.DiscriminatorHasPrefix(*i.DiscriminatorHasPrefix))
	}
	if i.DiscriminatorHasSuffix != nil {
		predicates = append(predicates, discordaccount.DiscriminatorHasSuffix(*i.DiscriminatorHasSuffix))
	}
	if i.DiscriminatorEqualFold != nil {
		predicates = append(predicates, discordaccount.DiscriminatorEqualFold(*i.DiscriminatorEqualFold))
	}
	if i.DiscriminatorContainsFold != nil {
		predicates = append(predicates, discordaccount.DiscriminatorContainsFold(*i.DiscriminatorContainsFold))
	}

	if i.HasOwner != nil {
		p := discordaccount.HasOwner()
		if !*i.HasOwner {
			p = discordaccount.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasOwnerWith) > 0 {
		with := make([]predicate.User, 0, len(i.HasOwnerWith))
		for _, w := range i.HasOwnerWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasOwnerWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, discordaccount.HasOwnerWith(with...))
	}
	if i.HasBot != nil {
		p := discordaccount.HasBot()
		if !*i.HasBot {
			p = discordaccount.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasBotWith) > 0 {
		with := make([]predicate.DiscordBot, 0, len(i.HasBotWith))
		for _, w := range i.HasBotWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasBotWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, discordaccount.HasBotWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyDiscordAccountWhereInput
	case 1:
		return predicates[0], nil
	default:
		return discordaccount.And(predicates...), nil
	}
}

// DiscordBotWhereInput represents a where input for filtering DiscordBot queries.
type DiscordBotWhereInput struct {
	Predicates []predicate.DiscordBot  `json:"-"`
	Not        *DiscordBotWhereInput   `json:"not,omitempty"`
	Or         []*DiscordBotWhereInput `json:"or,omitempty"`
	And        []*DiscordBotWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "account" edge predicates.
	HasAccount     *bool                       `json:"hasAccount,omitempty"`
	HasAccountWith []*DiscordAccountWhereInput `json:"hasAccountWith,omitempty"`

	// "project" edge predicates.
	HasProject     *bool                `json:"hasProject,omitempty"`
	HasProjectWith []*ProjectWhereInput `json:"hasProjectWith,omitempty"`

	// "repository" edge predicates.
	HasRepository     *bool                   `json:"hasRepository,omitempty"`
	HasRepositoryWith []*RepositoryWhereInput `json:"hasRepositoryWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *DiscordBotWhereInput) AddPredicates(predicates ...predicate.DiscordBot) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the DiscordBotWhereInput filter on the DiscordBotQuery builder.
func (i *DiscordBotWhereInput) Filter(q *DiscordBotQuery) (*DiscordBotQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyDiscordBotWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyDiscordBotWhereInput is returned in case the DiscordBotWhereInput is empty.
var ErrEmptyDiscordBotWhereInput = errors.New("ent: empty predicate DiscordBotWhereInput")

// P returns a predicate for filtering discordbots.
// An error is returned if the input is empty or invalid.
func (i *DiscordBotWhereInput) P() (predicate.DiscordBot, error) {
	var predicates []predicate.DiscordBot
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, discordbot.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.DiscordBot, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, discordbot.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.DiscordBot, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, discordbot.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, discordbot.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, discordbot.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, discordbot.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, discordbot.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, discordbot.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, discordbot.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, discordbot.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, discordbot.IDLTE(*i.IDLTE))
	}

	if i.HasAccount != nil {
		p := discordbot.HasAccount()
		if !*i.HasAccount {
			p = discordbot.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasAccountWith) > 0 {
		with := make([]predicate.DiscordAccount, 0, len(i.HasAccountWith))
		for _, w := range i.HasAccountWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasAccountWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, discordbot.HasAccountWith(with...))
	}
	if i.HasProject != nil {
		p := discordbot.HasProject()
		if !*i.HasProject {
			p = discordbot.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasProjectWith))
		for _, w := range i.HasProjectWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, discordbot.HasProjectWith(with...))
	}
	if i.HasRepository != nil {
		p := discordbot.HasRepository()
		if !*i.HasRepository {
			p = discordbot.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoryWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoryWith))
		for _, w := range i.HasRepositoryWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoryWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, discordbot.HasRepositoryWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyDiscordBotWhereInput
	case 1:
		return predicates[0], nil
	default:
		return discordbot.And(predicates...), nil
	}
}

// GithubAccountWhereInput represents a where input for filtering GithubAccount queries.
type GithubAccountWhereInput struct {
	Predicates []predicate.GithubAccount  `json:"-"`
	Not        *GithubAccountWhereInput   `json:"not,omitempty"`
	Or         []*GithubAccountWhereInput `json:"or,omitempty"`
	And        []*GithubAccountWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "username" field predicates.
	Username             *string  `json:"username,omitempty"`
	UsernameNEQ          *string  `json:"usernameNEQ,omitempty"`
	UsernameIn           []string `json:"usernameIn,omitempty"`
	UsernameNotIn        []string `json:"usernameNotIn,omitempty"`
	UsernameGT           *string  `json:"usernameGT,omitempty"`
	UsernameGTE          *string  `json:"usernameGTE,omitempty"`
	UsernameLT           *string  `json:"usernameLT,omitempty"`
	UsernameLTE          *string  `json:"usernameLTE,omitempty"`
	UsernameContains     *string  `json:"usernameContains,omitempty"`
	UsernameHasPrefix    *string  `json:"usernameHasPrefix,omitempty"`
	UsernameHasSuffix    *string  `json:"usernameHasSuffix,omitempty"`
	UsernameEqualFold    *string  `json:"usernameEqualFold,omitempty"`
	UsernameContainsFold *string  `json:"usernameContainsFold,omitempty"`

	// "owner" edge predicates.
	HasOwner     *bool             `json:"hasOwner,omitempty"`
	HasOwnerWith []*UserWhereInput `json:"hasOwnerWith,omitempty"`

	// "organization_memberships" edge predicates.
	HasOrganizationMemberships     *bool                                 `json:"hasOrganizationMemberships,omitempty"`
	HasOrganizationMembershipsWith []*GithubOrganizationMemberWhereInput `json:"hasOrganizationMembershipsWith,omitempty"`

	// "repositories" edge predicates.
	HasRepositories     *bool                   `json:"hasRepositories,omitempty"`
	HasRepositoriesWith []*RepositoryWhereInput `json:"hasRepositoriesWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *GithubAccountWhereInput) AddPredicates(predicates ...predicate.GithubAccount) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the GithubAccountWhereInput filter on the GithubAccountQuery builder.
func (i *GithubAccountWhereInput) Filter(q *GithubAccountQuery) (*GithubAccountQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyGithubAccountWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyGithubAccountWhereInput is returned in case the GithubAccountWhereInput is empty.
var ErrEmptyGithubAccountWhereInput = errors.New("ent: empty predicate GithubAccountWhereInput")

// P returns a predicate for filtering githubaccounts.
// An error is returned if the input is empty or invalid.
func (i *GithubAccountWhereInput) P() (predicate.GithubAccount, error) {
	var predicates []predicate.GithubAccount
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, githubaccount.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.GithubAccount, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, githubaccount.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.GithubAccount, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, githubaccount.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, githubaccount.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, githubaccount.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, githubaccount.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, githubaccount.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, githubaccount.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, githubaccount.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, githubaccount.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, githubaccount.IDLTE(*i.IDLTE))
	}
	if i.Username != nil {
		predicates = append(predicates, githubaccount.UsernameEQ(*i.Username))
	}
	if i.UsernameNEQ != nil {
		predicates = append(predicates, githubaccount.UsernameNEQ(*i.UsernameNEQ))
	}
	if len(i.UsernameIn) > 0 {
		predicates = append(predicates, githubaccount.UsernameIn(i.UsernameIn...))
	}
	if len(i.UsernameNotIn) > 0 {
		predicates = append(predicates, githubaccount.UsernameNotIn(i.UsernameNotIn...))
	}
	if i.UsernameGT != nil {
		predicates = append(predicates, githubaccount.UsernameGT(*i.UsernameGT))
	}
	if i.UsernameGTE != nil {
		predicates = append(predicates, githubaccount.UsernameGTE(*i.UsernameGTE))
	}
	if i.UsernameLT != nil {
		predicates = append(predicates, githubaccount.UsernameLT(*i.UsernameLT))
	}
	if i.UsernameLTE != nil {
		predicates = append(predicates, githubaccount.UsernameLTE(*i.UsernameLTE))
	}
	if i.UsernameContains != nil {
		predicates = append(predicates, githubaccount.UsernameContains(*i.UsernameContains))
	}
	if i.UsernameHasPrefix != nil {
		predicates = append(predicates, githubaccount.UsernameHasPrefix(*i.UsernameHasPrefix))
	}
	if i.UsernameHasSuffix != nil {
		predicates = append(predicates, githubaccount.UsernameHasSuffix(*i.UsernameHasSuffix))
	}
	if i.UsernameEqualFold != nil {
		predicates = append(predicates, githubaccount.UsernameEqualFold(*i.UsernameEqualFold))
	}
	if i.UsernameContainsFold != nil {
		predicates = append(predicates, githubaccount.UsernameContainsFold(*i.UsernameContainsFold))
	}

	if i.HasOwner != nil {
		p := githubaccount.HasOwner()
		if !*i.HasOwner {
			p = githubaccount.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasOwnerWith) > 0 {
		with := make([]predicate.User, 0, len(i.HasOwnerWith))
		for _, w := range i.HasOwnerWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasOwnerWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githubaccount.HasOwnerWith(with...))
	}
	if i.HasOrganizationMemberships != nil {
		p := githubaccount.HasOrganizationMemberships()
		if !*i.HasOrganizationMemberships {
			p = githubaccount.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasOrganizationMembershipsWith) > 0 {
		with := make([]predicate.GithubOrganizationMember, 0, len(i.HasOrganizationMembershipsWith))
		for _, w := range i.HasOrganizationMembershipsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasOrganizationMembershipsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githubaccount.HasOrganizationMembershipsWith(with...))
	}
	if i.HasRepositories != nil {
		p := githubaccount.HasRepositories()
		if !*i.HasRepositories {
			p = githubaccount.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoriesWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoriesWith))
		for _, w := range i.HasRepositoriesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoriesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githubaccount.HasRepositoriesWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyGithubAccountWhereInput
	case 1:
		return predicates[0], nil
	default:
		return githubaccount.And(predicates...), nil
	}
}

// GithubOrganizationWhereInput represents a where input for filtering GithubOrganization queries.
type GithubOrganizationWhereInput struct {
	Predicates []predicate.GithubOrganization  `json:"-"`
	Not        *GithubOrganizationWhereInput   `json:"not,omitempty"`
	Or         []*GithubOrganizationWhereInput `json:"or,omitempty"`
	And        []*GithubOrganizationWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "name" field predicates.
	Name             *string  `json:"name,omitempty"`
	NameNEQ          *string  `json:"nameNEQ,omitempty"`
	NameIn           []string `json:"nameIn,omitempty"`
	NameNotIn        []string `json:"nameNotIn,omitempty"`
	NameGT           *string  `json:"nameGT,omitempty"`
	NameGTE          *string  `json:"nameGTE,omitempty"`
	NameLT           *string  `json:"nameLT,omitempty"`
	NameLTE          *string  `json:"nameLTE,omitempty"`
	NameContains     *string  `json:"nameContains,omitempty"`
	NameHasPrefix    *string  `json:"nameHasPrefix,omitempty"`
	NameHasSuffix    *string  `json:"nameHasSuffix,omitempty"`
	NameEqualFold    *string  `json:"nameEqualFold,omitempty"`
	NameContainsFold *string  `json:"nameContainsFold,omitempty"`

	// "display_name" field predicates.
	DisplayName             *string  `json:"displayName,omitempty"`
	DisplayNameNEQ          *string  `json:"displayNameNEQ,omitempty"`
	DisplayNameIn           []string `json:"displayNameIn,omitempty"`
	DisplayNameNotIn        []string `json:"displayNameNotIn,omitempty"`
	DisplayNameGT           *string  `json:"displayNameGT,omitempty"`
	DisplayNameGTE          *string  `json:"displayNameGTE,omitempty"`
	DisplayNameLT           *string  `json:"displayNameLT,omitempty"`
	DisplayNameLTE          *string  `json:"displayNameLTE,omitempty"`
	DisplayNameContains     *string  `json:"displayNameContains,omitempty"`
	DisplayNameHasPrefix    *string  `json:"displayNameHasPrefix,omitempty"`
	DisplayNameHasSuffix    *string  `json:"displayNameHasSuffix,omitempty"`
	DisplayNameIsNil        bool     `json:"displayNameIsNil,omitempty"`
	DisplayNameNotNil       bool     `json:"displayNameNotNil,omitempty"`
	DisplayNameEqualFold    *string  `json:"displayNameEqualFold,omitempty"`
	DisplayNameContainsFold *string  `json:"displayNameContainsFold,omitempty"`

	// "members" edge predicates.
	HasMembers     *bool                                 `json:"hasMembers,omitempty"`
	HasMembersWith []*GithubOrganizationMemberWhereInput `json:"hasMembersWith,omitempty"`

	// "repositories" edge predicates.
	HasRepositories     *bool                   `json:"hasRepositories,omitempty"`
	HasRepositoriesWith []*RepositoryWhereInput `json:"hasRepositoriesWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *GithubOrganizationWhereInput) AddPredicates(predicates ...predicate.GithubOrganization) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the GithubOrganizationWhereInput filter on the GithubOrganizationQuery builder.
func (i *GithubOrganizationWhereInput) Filter(q *GithubOrganizationQuery) (*GithubOrganizationQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyGithubOrganizationWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyGithubOrganizationWhereInput is returned in case the GithubOrganizationWhereInput is empty.
var ErrEmptyGithubOrganizationWhereInput = errors.New("ent: empty predicate GithubOrganizationWhereInput")

// P returns a predicate for filtering githuborganizations.
// An error is returned if the input is empty or invalid.
func (i *GithubOrganizationWhereInput) P() (predicate.GithubOrganization, error) {
	var predicates []predicate.GithubOrganization
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, githuborganization.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.GithubOrganization, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, githuborganization.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.GithubOrganization, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, githuborganization.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, githuborganization.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, githuborganization.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, githuborganization.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, githuborganization.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, githuborganization.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, githuborganization.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, githuborganization.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, githuborganization.IDLTE(*i.IDLTE))
	}
	if i.Name != nil {
		predicates = append(predicates, githuborganization.NameEQ(*i.Name))
	}
	if i.NameNEQ != nil {
		predicates = append(predicates, githuborganization.NameNEQ(*i.NameNEQ))
	}
	if len(i.NameIn) > 0 {
		predicates = append(predicates, githuborganization.NameIn(i.NameIn...))
	}
	if len(i.NameNotIn) > 0 {
		predicates = append(predicates, githuborganization.NameNotIn(i.NameNotIn...))
	}
	if i.NameGT != nil {
		predicates = append(predicates, githuborganization.NameGT(*i.NameGT))
	}
	if i.NameGTE != nil {
		predicates = append(predicates, githuborganization.NameGTE(*i.NameGTE))
	}
	if i.NameLT != nil {
		predicates = append(predicates, githuborganization.NameLT(*i.NameLT))
	}
	if i.NameLTE != nil {
		predicates = append(predicates, githuborganization.NameLTE(*i.NameLTE))
	}
	if i.NameContains != nil {
		predicates = append(predicates, githuborganization.NameContains(*i.NameContains))
	}
	if i.NameHasPrefix != nil {
		predicates = append(predicates, githuborganization.NameHasPrefix(*i.NameHasPrefix))
	}
	if i.NameHasSuffix != nil {
		predicates = append(predicates, githuborganization.NameHasSuffix(*i.NameHasSuffix))
	}
	if i.NameEqualFold != nil {
		predicates = append(predicates, githuborganization.NameEqualFold(*i.NameEqualFold))
	}
	if i.NameContainsFold != nil {
		predicates = append(predicates, githuborganization.NameContainsFold(*i.NameContainsFold))
	}
	if i.DisplayName != nil {
		predicates = append(predicates, githuborganization.DisplayNameEQ(*i.DisplayName))
	}
	if i.DisplayNameNEQ != nil {
		predicates = append(predicates, githuborganization.DisplayNameNEQ(*i.DisplayNameNEQ))
	}
	if len(i.DisplayNameIn) > 0 {
		predicates = append(predicates, githuborganization.DisplayNameIn(i.DisplayNameIn...))
	}
	if len(i.DisplayNameNotIn) > 0 {
		predicates = append(predicates, githuborganization.DisplayNameNotIn(i.DisplayNameNotIn...))
	}
	if i.DisplayNameGT != nil {
		predicates = append(predicates, githuborganization.DisplayNameGT(*i.DisplayNameGT))
	}
	if i.DisplayNameGTE != nil {
		predicates = append(predicates, githuborganization.DisplayNameGTE(*i.DisplayNameGTE))
	}
	if i.DisplayNameLT != nil {
		predicates = append(predicates, githuborganization.DisplayNameLT(*i.DisplayNameLT))
	}
	if i.DisplayNameLTE != nil {
		predicates = append(predicates, githuborganization.DisplayNameLTE(*i.DisplayNameLTE))
	}
	if i.DisplayNameContains != nil {
		predicates = append(predicates, githuborganization.DisplayNameContains(*i.DisplayNameContains))
	}
	if i.DisplayNameHasPrefix != nil {
		predicates = append(predicates, githuborganization.DisplayNameHasPrefix(*i.DisplayNameHasPrefix))
	}
	if i.DisplayNameHasSuffix != nil {
		predicates = append(predicates, githuborganization.DisplayNameHasSuffix(*i.DisplayNameHasSuffix))
	}
	if i.DisplayNameIsNil {
		predicates = append(predicates, githuborganization.DisplayNameIsNil())
	}
	if i.DisplayNameNotNil {
		predicates = append(predicates, githuborganization.DisplayNameNotNil())
	}
	if i.DisplayNameEqualFold != nil {
		predicates = append(predicates, githuborganization.DisplayNameEqualFold(*i.DisplayNameEqualFold))
	}
	if i.DisplayNameContainsFold != nil {
		predicates = append(predicates, githuborganization.DisplayNameContainsFold(*i.DisplayNameContainsFold))
	}

	if i.HasMembers != nil {
		p := githuborganization.HasMembers()
		if !*i.HasMembers {
			p = githuborganization.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasMembersWith) > 0 {
		with := make([]predicate.GithubOrganizationMember, 0, len(i.HasMembersWith))
		for _, w := range i.HasMembersWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasMembersWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githuborganization.HasMembersWith(with...))
	}
	if i.HasRepositories != nil {
		p := githuborganization.HasRepositories()
		if !*i.HasRepositories {
			p = githuborganization.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoriesWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoriesWith))
		for _, w := range i.HasRepositoriesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoriesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githuborganization.HasRepositoriesWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyGithubOrganizationWhereInput
	case 1:
		return predicates[0], nil
	default:
		return githuborganization.And(predicates...), nil
	}
}

// GithubOrganizationMemberWhereInput represents a where input for filtering GithubOrganizationMember queries.
type GithubOrganizationMemberWhereInput struct {
	Predicates []predicate.GithubOrganizationMember  `json:"-"`
	Not        *GithubOrganizationMemberWhereInput   `json:"not,omitempty"`
	Or         []*GithubOrganizationMemberWhereInput `json:"or,omitempty"`
	And        []*GithubOrganizationMemberWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "role" field predicates.
	Role      *githuborganizationmember.Role  `json:"role,omitempty"`
	RoleNEQ   *githuborganizationmember.Role  `json:"roleNEQ,omitempty"`
	RoleIn    []githuborganizationmember.Role `json:"roleIn,omitempty"`
	RoleNotIn []githuborganizationmember.Role `json:"roleNotIn,omitempty"`

	// "organization" edge predicates.
	HasOrganization     *bool                           `json:"hasOrganization,omitempty"`
	HasOrganizationWith []*GithubOrganizationWhereInput `json:"hasOrganizationWith,omitempty"`

	// "account" edge predicates.
	HasAccount     *bool                      `json:"hasAccount,omitempty"`
	HasAccountWith []*GithubAccountWhereInput `json:"hasAccountWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *GithubOrganizationMemberWhereInput) AddPredicates(predicates ...predicate.GithubOrganizationMember) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the GithubOrganizationMemberWhereInput filter on the GithubOrganizationMemberQuery builder.
func (i *GithubOrganizationMemberWhereInput) Filter(q *GithubOrganizationMemberQuery) (*GithubOrganizationMemberQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyGithubOrganizationMemberWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyGithubOrganizationMemberWhereInput is returned in case the GithubOrganizationMemberWhereInput is empty.
var ErrEmptyGithubOrganizationMemberWhereInput = errors.New("ent: empty predicate GithubOrganizationMemberWhereInput")

// P returns a predicate for filtering githuborganizationmembers.
// An error is returned if the input is empty or invalid.
func (i *GithubOrganizationMemberWhereInput) P() (predicate.GithubOrganizationMember, error) {
	var predicates []predicate.GithubOrganizationMember
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, githuborganizationmember.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.GithubOrganizationMember, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, githuborganizationmember.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.GithubOrganizationMember, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, githuborganizationmember.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, githuborganizationmember.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, githuborganizationmember.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, githuborganizationmember.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, githuborganizationmember.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, githuborganizationmember.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, githuborganizationmember.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, githuborganizationmember.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, githuborganizationmember.IDLTE(*i.IDLTE))
	}
	if i.Role != nil {
		predicates = append(predicates, githuborganizationmember.RoleEQ(*i.Role))
	}
	if i.RoleNEQ != nil {
		predicates = append(predicates, githuborganizationmember.RoleNEQ(*i.RoleNEQ))
	}
	if len(i.RoleIn) > 0 {
		predicates = append(predicates, githuborganizationmember.RoleIn(i.RoleIn...))
	}
	if len(i.RoleNotIn) > 0 {
		predicates = append(predicates, githuborganizationmember.RoleNotIn(i.RoleNotIn...))
	}

	if i.HasOrganization != nil {
		p := githuborganizationmember.HasOrganization()
		if !*i.HasOrganization {
			p = githuborganizationmember.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasOrganizationWith) > 0 {
		with := make([]predicate.GithubOrganization, 0, len(i.HasOrganizationWith))
		for _, w := range i.HasOrganizationWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasOrganizationWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githuborganizationmember.HasOrganizationWith(with...))
	}
	if i.HasAccount != nil {
		p := githuborganizationmember.HasAccount()
		if !*i.HasAccount {
			p = githuborganizationmember.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasAccountWith) > 0 {
		with := make([]predicate.GithubAccount, 0, len(i.HasAccountWith))
		for _, w := range i.HasAccountWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasAccountWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, githuborganizationmember.HasAccountWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyGithubOrganizationMemberWhereInput
	case 1:
		return predicates[0], nil
	default:
		return githuborganizationmember.And(predicates...), nil
	}
}

// ProjectWhereInput represents a where input for filtering Project queries.
type ProjectWhereInput struct {
	Predicates []predicate.Project  `json:"-"`
	Not        *ProjectWhereInput   `json:"not,omitempty"`
	Or         []*ProjectWhereInput `json:"or,omitempty"`
	And        []*ProjectWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "name" field predicates.
	Name             *string  `json:"name,omitempty"`
	NameNEQ          *string  `json:"nameNEQ,omitempty"`
	NameIn           []string `json:"nameIn,omitempty"`
	NameNotIn        []string `json:"nameNotIn,omitempty"`
	NameGT           *string  `json:"nameGT,omitempty"`
	NameGTE          *string  `json:"nameGTE,omitempty"`
	NameLT           *string  `json:"nameLT,omitempty"`
	NameLTE          *string  `json:"nameLTE,omitempty"`
	NameContains     *string  `json:"nameContains,omitempty"`
	NameHasPrefix    *string  `json:"nameHasPrefix,omitempty"`
	NameHasSuffix    *string  `json:"nameHasSuffix,omitempty"`
	NameEqualFold    *string  `json:"nameEqualFold,omitempty"`
	NameContainsFold *string  `json:"nameContainsFold,omitempty"`

	// "description" field predicates.
	Description             *string  `json:"description,omitempty"`
	DescriptionNEQ          *string  `json:"descriptionNEQ,omitempty"`
	DescriptionIn           []string `json:"descriptionIn,omitempty"`
	DescriptionNotIn        []string `json:"descriptionNotIn,omitempty"`
	DescriptionGT           *string  `json:"descriptionGT,omitempty"`
	DescriptionGTE          *string  `json:"descriptionGTE,omitempty"`
	DescriptionLT           *string  `json:"descriptionLT,omitempty"`
	DescriptionLTE          *string  `json:"descriptionLTE,omitempty"`
	DescriptionContains     *string  `json:"descriptionContains,omitempty"`
	DescriptionHasPrefix    *string  `json:"descriptionHasPrefix,omitempty"`
	DescriptionHasSuffix    *string  `json:"descriptionHasSuffix,omitempty"`
	DescriptionIsNil        bool     `json:"descriptionIsNil,omitempty"`
	DescriptionNotNil       bool     `json:"descriptionNotNil,omitempty"`
	DescriptionEqualFold    *string  `json:"descriptionEqualFold,omitempty"`
	DescriptionContainsFold *string  `json:"descriptionContainsFold,omitempty"`

	// "start_date" field predicates.
	StartDate      *time.Time  `json:"startDate,omitempty"`
	StartDateNEQ   *time.Time  `json:"startDateNEQ,omitempty"`
	StartDateIn    []time.Time `json:"startDateIn,omitempty"`
	StartDateNotIn []time.Time `json:"startDateNotIn,omitempty"`
	StartDateGT    *time.Time  `json:"startDateGT,omitempty"`
	StartDateGTE   *time.Time  `json:"startDateGTE,omitempty"`
	StartDateLT    *time.Time  `json:"startDateLT,omitempty"`
	StartDateLTE   *time.Time  `json:"startDateLTE,omitempty"`

	// "end_date" field predicates.
	EndDate       *time.Time  `json:"endDate,omitempty"`
	EndDateNEQ    *time.Time  `json:"endDateNEQ,omitempty"`
	EndDateIn     []time.Time `json:"endDateIn,omitempty"`
	EndDateNotIn  []time.Time `json:"endDateNotIn,omitempty"`
	EndDateGT     *time.Time  `json:"endDateGT,omitempty"`
	EndDateGTE    *time.Time  `json:"endDateGTE,omitempty"`
	EndDateLT     *time.Time  `json:"endDateLT,omitempty"`
	EndDateLTE    *time.Time  `json:"endDateLTE,omitempty"`
	EndDateIsNil  bool        `json:"endDateIsNil,omitempty"`
	EndDateNotNil bool        `json:"endDateNotNil,omitempty"`

	// "contributors" edge predicates.
	HasContributors     *bool                           `json:"hasContributors,omitempty"`
	HasContributorsWith []*ProjectContributorWhereInput `json:"hasContributorsWith,omitempty"`

	// "parent_projects" edge predicates.
	HasParentProjects     *bool                           `json:"hasParentProjects,omitempty"`
	HasParentProjectsWith []*ProjectAssociationWhereInput `json:"hasParentProjectsWith,omitempty"`

	// "child_projects" edge predicates.
	HasChildProjects     *bool                           `json:"hasChildProjects,omitempty"`
	HasChildProjectsWith []*ProjectAssociationWhereInput `json:"hasChildProjectsWith,omitempty"`

	// "repositories" edge predicates.
	HasRepositories     *bool                   `json:"hasRepositories,omitempty"`
	HasRepositoriesWith []*RepositoryWhereInput `json:"hasRepositoriesWith,omitempty"`

	// "discord_bots" edge predicates.
	HasDiscordBots     *bool                   `json:"hasDiscordBots,omitempty"`
	HasDiscordBotsWith []*DiscordBotWhereInput `json:"hasDiscordBotsWith,omitempty"`

	// "sites" edge predicates.
	HasSites     *bool             `json:"hasSites,omitempty"`
	HasSitesWith []*SiteWhereInput `json:"hasSitesWith,omitempty"`

	// "technologies" edge predicates.
	HasTechnologies     *bool                          `json:"hasTechnologies,omitempty"`
	HasTechnologiesWith []*ProjectTechnologyWhereInput `json:"hasTechnologiesWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *ProjectWhereInput) AddPredicates(predicates ...predicate.Project) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the ProjectWhereInput filter on the ProjectQuery builder.
func (i *ProjectWhereInput) Filter(q *ProjectQuery) (*ProjectQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyProjectWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyProjectWhereInput is returned in case the ProjectWhereInput is empty.
var ErrEmptyProjectWhereInput = errors.New("ent: empty predicate ProjectWhereInput")

// P returns a predicate for filtering projects.
// An error is returned if the input is empty or invalid.
func (i *ProjectWhereInput) P() (predicate.Project, error) {
	var predicates []predicate.Project
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, project.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.Project, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, project.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.Project, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, project.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, project.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, project.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, project.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, project.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, project.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, project.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, project.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, project.IDLTE(*i.IDLTE))
	}
	if i.Name != nil {
		predicates = append(predicates, project.NameEQ(*i.Name))
	}
	if i.NameNEQ != nil {
		predicates = append(predicates, project.NameNEQ(*i.NameNEQ))
	}
	if len(i.NameIn) > 0 {
		predicates = append(predicates, project.NameIn(i.NameIn...))
	}
	if len(i.NameNotIn) > 0 {
		predicates = append(predicates, project.NameNotIn(i.NameNotIn...))
	}
	if i.NameGT != nil {
		predicates = append(predicates, project.NameGT(*i.NameGT))
	}
	if i.NameGTE != nil {
		predicates = append(predicates, project.NameGTE(*i.NameGTE))
	}
	if i.NameLT != nil {
		predicates = append(predicates, project.NameLT(*i.NameLT))
	}
	if i.NameLTE != nil {
		predicates = append(predicates, project.NameLTE(*i.NameLTE))
	}
	if i.NameContains != nil {
		predicates = append(predicates, project.NameContains(*i.NameContains))
	}
	if i.NameHasPrefix != nil {
		predicates = append(predicates, project.NameHasPrefix(*i.NameHasPrefix))
	}
	if i.NameHasSuffix != nil {
		predicates = append(predicates, project.NameHasSuffix(*i.NameHasSuffix))
	}
	if i.NameEqualFold != nil {
		predicates = append(predicates, project.NameEqualFold(*i.NameEqualFold))
	}
	if i.NameContainsFold != nil {
		predicates = append(predicates, project.NameContainsFold(*i.NameContainsFold))
	}
	if i.Description != nil {
		predicates = append(predicates, project.DescriptionEQ(*i.Description))
	}
	if i.DescriptionNEQ != nil {
		predicates = append(predicates, project.DescriptionNEQ(*i.DescriptionNEQ))
	}
	if len(i.DescriptionIn) > 0 {
		predicates = append(predicates, project.DescriptionIn(i.DescriptionIn...))
	}
	if len(i.DescriptionNotIn) > 0 {
		predicates = append(predicates, project.DescriptionNotIn(i.DescriptionNotIn...))
	}
	if i.DescriptionGT != nil {
		predicates = append(predicates, project.DescriptionGT(*i.DescriptionGT))
	}
	if i.DescriptionGTE != nil {
		predicates = append(predicates, project.DescriptionGTE(*i.DescriptionGTE))
	}
	if i.DescriptionLT != nil {
		predicates = append(predicates, project.DescriptionLT(*i.DescriptionLT))
	}
	if i.DescriptionLTE != nil {
		predicates = append(predicates, project.DescriptionLTE(*i.DescriptionLTE))
	}
	if i.DescriptionContains != nil {
		predicates = append(predicates, project.DescriptionContains(*i.DescriptionContains))
	}
	if i.DescriptionHasPrefix != nil {
		predicates = append(predicates, project.DescriptionHasPrefix(*i.DescriptionHasPrefix))
	}
	if i.DescriptionHasSuffix != nil {
		predicates = append(predicates, project.DescriptionHasSuffix(*i.DescriptionHasSuffix))
	}
	if i.DescriptionIsNil {
		predicates = append(predicates, project.DescriptionIsNil())
	}
	if i.DescriptionNotNil {
		predicates = append(predicates, project.DescriptionNotNil())
	}
	if i.DescriptionEqualFold != nil {
		predicates = append(predicates, project.DescriptionEqualFold(*i.DescriptionEqualFold))
	}
	if i.DescriptionContainsFold != nil {
		predicates = append(predicates, project.DescriptionContainsFold(*i.DescriptionContainsFold))
	}
	if i.StartDate != nil {
		predicates = append(predicates, project.StartDateEQ(*i.StartDate))
	}
	if i.StartDateNEQ != nil {
		predicates = append(predicates, project.StartDateNEQ(*i.StartDateNEQ))
	}
	if len(i.StartDateIn) > 0 {
		predicates = append(predicates, project.StartDateIn(i.StartDateIn...))
	}
	if len(i.StartDateNotIn) > 0 {
		predicates = append(predicates, project.StartDateNotIn(i.StartDateNotIn...))
	}
	if i.StartDateGT != nil {
		predicates = append(predicates, project.StartDateGT(*i.StartDateGT))
	}
	if i.StartDateGTE != nil {
		predicates = append(predicates, project.StartDateGTE(*i.StartDateGTE))
	}
	if i.StartDateLT != nil {
		predicates = append(predicates, project.StartDateLT(*i.StartDateLT))
	}
	if i.StartDateLTE != nil {
		predicates = append(predicates, project.StartDateLTE(*i.StartDateLTE))
	}
	if i.EndDate != nil {
		predicates = append(predicates, project.EndDateEQ(*i.EndDate))
	}
	if i.EndDateNEQ != nil {
		predicates = append(predicates, project.EndDateNEQ(*i.EndDateNEQ))
	}
	if len(i.EndDateIn) > 0 {
		predicates = append(predicates, project.EndDateIn(i.EndDateIn...))
	}
	if len(i.EndDateNotIn) > 0 {
		predicates = append(predicates, project.EndDateNotIn(i.EndDateNotIn...))
	}
	if i.EndDateGT != nil {
		predicates = append(predicates, project.EndDateGT(*i.EndDateGT))
	}
	if i.EndDateGTE != nil {
		predicates = append(predicates, project.EndDateGTE(*i.EndDateGTE))
	}
	if i.EndDateLT != nil {
		predicates = append(predicates, project.EndDateLT(*i.EndDateLT))
	}
	if i.EndDateLTE != nil {
		predicates = append(predicates, project.EndDateLTE(*i.EndDateLTE))
	}
	if i.EndDateIsNil {
		predicates = append(predicates, project.EndDateIsNil())
	}
	if i.EndDateNotNil {
		predicates = append(predicates, project.EndDateNotNil())
	}

	if i.HasContributors != nil {
		p := project.HasContributors()
		if !*i.HasContributors {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasContributorsWith) > 0 {
		with := make([]predicate.ProjectContributor, 0, len(i.HasContributorsWith))
		for _, w := range i.HasContributorsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasContributorsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasContributorsWith(with...))
	}
	if i.HasParentProjects != nil {
		p := project.HasParentProjects()
		if !*i.HasParentProjects {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasParentProjectsWith) > 0 {
		with := make([]predicate.ProjectAssociation, 0, len(i.HasParentProjectsWith))
		for _, w := range i.HasParentProjectsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasParentProjectsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasParentProjectsWith(with...))
	}
	if i.HasChildProjects != nil {
		p := project.HasChildProjects()
		if !*i.HasChildProjects {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasChildProjectsWith) > 0 {
		with := make([]predicate.ProjectAssociation, 0, len(i.HasChildProjectsWith))
		for _, w := range i.HasChildProjectsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasChildProjectsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasChildProjectsWith(with...))
	}
	if i.HasRepositories != nil {
		p := project.HasRepositories()
		if !*i.HasRepositories {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoriesWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoriesWith))
		for _, w := range i.HasRepositoriesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoriesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasRepositoriesWith(with...))
	}
	if i.HasDiscordBots != nil {
		p := project.HasDiscordBots()
		if !*i.HasDiscordBots {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasDiscordBotsWith) > 0 {
		with := make([]predicate.DiscordBot, 0, len(i.HasDiscordBotsWith))
		for _, w := range i.HasDiscordBotsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasDiscordBotsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasDiscordBotsWith(with...))
	}
	if i.HasSites != nil {
		p := project.HasSites()
		if !*i.HasSites {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasSitesWith) > 0 {
		with := make([]predicate.Site, 0, len(i.HasSitesWith))
		for _, w := range i.HasSitesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasSitesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasSitesWith(with...))
	}
	if i.HasTechnologies != nil {
		p := project.HasTechnologies()
		if !*i.HasTechnologies {
			p = project.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasTechnologiesWith) > 0 {
		with := make([]predicate.ProjectTechnology, 0, len(i.HasTechnologiesWith))
		for _, w := range i.HasTechnologiesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasTechnologiesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, project.HasTechnologiesWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyProjectWhereInput
	case 1:
		return predicates[0], nil
	default:
		return project.And(predicates...), nil
	}
}

// ProjectAssociationWhereInput represents a where input for filtering ProjectAssociation queries.
type ProjectAssociationWhereInput struct {
	Predicates []predicate.ProjectAssociation  `json:"-"`
	Not        *ProjectAssociationWhereInput   `json:"not,omitempty"`
	Or         []*ProjectAssociationWhereInput `json:"or,omitempty"`
	And        []*ProjectAssociationWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "type" field predicates.
	Type      *projectassociation.Type  `json:"type,omitempty"`
	TypeNEQ   *projectassociation.Type  `json:"typeNEQ,omitempty"`
	TypeIn    []projectassociation.Type `json:"typeIn,omitempty"`
	TypeNotIn []projectassociation.Type `json:"typeNotIn,omitempty"`

	// "parent" edge predicates.
	HasParent     *bool                `json:"hasParent,omitempty"`
	HasParentWith []*ProjectWhereInput `json:"hasParentWith,omitempty"`

	// "child" edge predicates.
	HasChild     *bool                `json:"hasChild,omitempty"`
	HasChildWith []*ProjectWhereInput `json:"hasChildWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *ProjectAssociationWhereInput) AddPredicates(predicates ...predicate.ProjectAssociation) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the ProjectAssociationWhereInput filter on the ProjectAssociationQuery builder.
func (i *ProjectAssociationWhereInput) Filter(q *ProjectAssociationQuery) (*ProjectAssociationQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyProjectAssociationWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyProjectAssociationWhereInput is returned in case the ProjectAssociationWhereInput is empty.
var ErrEmptyProjectAssociationWhereInput = errors.New("ent: empty predicate ProjectAssociationWhereInput")

// P returns a predicate for filtering projectassociations.
// An error is returned if the input is empty or invalid.
func (i *ProjectAssociationWhereInput) P() (predicate.ProjectAssociation, error) {
	var predicates []predicate.ProjectAssociation
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, projectassociation.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.ProjectAssociation, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, projectassociation.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.ProjectAssociation, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, projectassociation.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, projectassociation.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, projectassociation.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, projectassociation.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, projectassociation.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, projectassociation.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, projectassociation.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, projectassociation.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, projectassociation.IDLTE(*i.IDLTE))
	}
	if i.Type != nil {
		predicates = append(predicates, projectassociation.TypeEQ(*i.Type))
	}
	if i.TypeNEQ != nil {
		predicates = append(predicates, projectassociation.TypeNEQ(*i.TypeNEQ))
	}
	if len(i.TypeIn) > 0 {
		predicates = append(predicates, projectassociation.TypeIn(i.TypeIn...))
	}
	if len(i.TypeNotIn) > 0 {
		predicates = append(predicates, projectassociation.TypeNotIn(i.TypeNotIn...))
	}

	if i.HasParent != nil {
		p := projectassociation.HasParent()
		if !*i.HasParent {
			p = projectassociation.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasParentWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasParentWith))
		for _, w := range i.HasParentWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasParentWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projectassociation.HasParentWith(with...))
	}
	if i.HasChild != nil {
		p := projectassociation.HasChild()
		if !*i.HasChild {
			p = projectassociation.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasChildWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasChildWith))
		for _, w := range i.HasChildWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasChildWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projectassociation.HasChildWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyProjectAssociationWhereInput
	case 1:
		return predicates[0], nil
	default:
		return projectassociation.And(predicates...), nil
	}
}

// ProjectContributorWhereInput represents a where input for filtering ProjectContributor queries.
type ProjectContributorWhereInput struct {
	Predicates []predicate.ProjectContributor  `json:"-"`
	Not        *ProjectContributorWhereInput   `json:"not,omitempty"`
	Or         []*ProjectContributorWhereInput `json:"or,omitempty"`
	And        []*ProjectContributorWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "role" field predicates.
	Role      *projectcontributor.Role  `json:"role,omitempty"`
	RoleNEQ   *projectcontributor.Role  `json:"roleNEQ,omitempty"`
	RoleIn    []projectcontributor.Role `json:"roleIn,omitempty"`
	RoleNotIn []projectcontributor.Role `json:"roleNotIn,omitempty"`

	// "project" edge predicates.
	HasProject     *bool                `json:"hasProject,omitempty"`
	HasProjectWith []*ProjectWhereInput `json:"hasProjectWith,omitempty"`

	// "user" edge predicates.
	HasUser     *bool             `json:"hasUser,omitempty"`
	HasUserWith []*UserWhereInput `json:"hasUserWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *ProjectContributorWhereInput) AddPredicates(predicates ...predicate.ProjectContributor) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the ProjectContributorWhereInput filter on the ProjectContributorQuery builder.
func (i *ProjectContributorWhereInput) Filter(q *ProjectContributorQuery) (*ProjectContributorQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyProjectContributorWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyProjectContributorWhereInput is returned in case the ProjectContributorWhereInput is empty.
var ErrEmptyProjectContributorWhereInput = errors.New("ent: empty predicate ProjectContributorWhereInput")

// P returns a predicate for filtering projectcontributors.
// An error is returned if the input is empty or invalid.
func (i *ProjectContributorWhereInput) P() (predicate.ProjectContributor, error) {
	var predicates []predicate.ProjectContributor
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, projectcontributor.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.ProjectContributor, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, projectcontributor.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.ProjectContributor, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, projectcontributor.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, projectcontributor.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, projectcontributor.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, projectcontributor.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, projectcontributor.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, projectcontributor.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, projectcontributor.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, projectcontributor.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, projectcontributor.IDLTE(*i.IDLTE))
	}
	if i.Role != nil {
		predicates = append(predicates, projectcontributor.RoleEQ(*i.Role))
	}
	if i.RoleNEQ != nil {
		predicates = append(predicates, projectcontributor.RoleNEQ(*i.RoleNEQ))
	}
	if len(i.RoleIn) > 0 {
		predicates = append(predicates, projectcontributor.RoleIn(i.RoleIn...))
	}
	if len(i.RoleNotIn) > 0 {
		predicates = append(predicates, projectcontributor.RoleNotIn(i.RoleNotIn...))
	}

	if i.HasProject != nil {
		p := projectcontributor.HasProject()
		if !*i.HasProject {
			p = projectcontributor.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasProjectWith))
		for _, w := range i.HasProjectWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projectcontributor.HasProjectWith(with...))
	}
	if i.HasUser != nil {
		p := projectcontributor.HasUser()
		if !*i.HasUser {
			p = projectcontributor.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasUserWith) > 0 {
		with := make([]predicate.User, 0, len(i.HasUserWith))
		for _, w := range i.HasUserWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasUserWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projectcontributor.HasUserWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyProjectContributorWhereInput
	case 1:
		return predicates[0], nil
	default:
		return projectcontributor.And(predicates...), nil
	}
}

// ProjectTechnologyWhereInput represents a where input for filtering ProjectTechnology queries.
type ProjectTechnologyWhereInput struct {
	Predicates []predicate.ProjectTechnology  `json:"-"`
	Not        *ProjectTechnologyWhereInput   `json:"not,omitempty"`
	Or         []*ProjectTechnologyWhereInput `json:"or,omitempty"`
	And        []*ProjectTechnologyWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "type" field predicates.
	Type      *projecttechnology.Type  `json:"type,omitempty"`
	TypeNEQ   *projecttechnology.Type  `json:"typeNEQ,omitempty"`
	TypeIn    []projecttechnology.Type `json:"typeIn,omitempty"`
	TypeNotIn []projecttechnology.Type `json:"typeNotIn,omitempty"`

	// "project" edge predicates.
	HasProject     *bool                `json:"hasProject,omitempty"`
	HasProjectWith []*ProjectWhereInput `json:"hasProjectWith,omitempty"`

	// "technology" edge predicates.
	HasTechnology     *bool                   `json:"hasTechnology,omitempty"`
	HasTechnologyWith []*TechnologyWhereInput `json:"hasTechnologyWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *ProjectTechnologyWhereInput) AddPredicates(predicates ...predicate.ProjectTechnology) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the ProjectTechnologyWhereInput filter on the ProjectTechnologyQuery builder.
func (i *ProjectTechnologyWhereInput) Filter(q *ProjectTechnologyQuery) (*ProjectTechnologyQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyProjectTechnologyWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyProjectTechnologyWhereInput is returned in case the ProjectTechnologyWhereInput is empty.
var ErrEmptyProjectTechnologyWhereInput = errors.New("ent: empty predicate ProjectTechnologyWhereInput")

// P returns a predicate for filtering projecttechnologies.
// An error is returned if the input is empty or invalid.
func (i *ProjectTechnologyWhereInput) P() (predicate.ProjectTechnology, error) {
	var predicates []predicate.ProjectTechnology
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, projecttechnology.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.ProjectTechnology, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, projecttechnology.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.ProjectTechnology, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, projecttechnology.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, projecttechnology.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, projecttechnology.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, projecttechnology.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, projecttechnology.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, projecttechnology.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, projecttechnology.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, projecttechnology.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, projecttechnology.IDLTE(*i.IDLTE))
	}
	if i.Type != nil {
		predicates = append(predicates, projecttechnology.TypeEQ(*i.Type))
	}
	if i.TypeNEQ != nil {
		predicates = append(predicates, projecttechnology.TypeNEQ(*i.TypeNEQ))
	}
	if len(i.TypeIn) > 0 {
		predicates = append(predicates, projecttechnology.TypeIn(i.TypeIn...))
	}
	if len(i.TypeNotIn) > 0 {
		predicates = append(predicates, projecttechnology.TypeNotIn(i.TypeNotIn...))
	}

	if i.HasProject != nil {
		p := projecttechnology.HasProject()
		if !*i.HasProject {
			p = projecttechnology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasProjectWith))
		for _, w := range i.HasProjectWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projecttechnology.HasProjectWith(with...))
	}
	if i.HasTechnology != nil {
		p := projecttechnology.HasTechnology()
		if !*i.HasTechnology {
			p = projecttechnology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasTechnologyWith) > 0 {
		with := make([]predicate.Technology, 0, len(i.HasTechnologyWith))
		for _, w := range i.HasTechnologyWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasTechnologyWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, projecttechnology.HasTechnologyWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyProjectTechnologyWhereInput
	case 1:
		return predicates[0], nil
	default:
		return projecttechnology.And(predicates...), nil
	}
}

// RepositoryWhereInput represents a where input for filtering Repository queries.
type RepositoryWhereInput struct {
	Predicates []predicate.Repository  `json:"-"`
	Not        *RepositoryWhereInput   `json:"not,omitempty"`
	Or         []*RepositoryWhereInput `json:"or,omitempty"`
	And        []*RepositoryWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "name" field predicates.
	Name             *string  `json:"name,omitempty"`
	NameNEQ          *string  `json:"nameNEQ,omitempty"`
	NameIn           []string `json:"nameIn,omitempty"`
	NameNotIn        []string `json:"nameNotIn,omitempty"`
	NameGT           *string  `json:"nameGT,omitempty"`
	NameGTE          *string  `json:"nameGTE,omitempty"`
	NameLT           *string  `json:"nameLT,omitempty"`
	NameLTE          *string  `json:"nameLTE,omitempty"`
	NameContains     *string  `json:"nameContains,omitempty"`
	NameHasPrefix    *string  `json:"nameHasPrefix,omitempty"`
	NameHasSuffix    *string  `json:"nameHasSuffix,omitempty"`
	NameEqualFold    *string  `json:"nameEqualFold,omitempty"`
	NameContainsFold *string  `json:"nameContainsFold,omitempty"`

	// "description" field predicates.
	Description             *string  `json:"description,omitempty"`
	DescriptionNEQ          *string  `json:"descriptionNEQ,omitempty"`
	DescriptionIn           []string `json:"descriptionIn,omitempty"`
	DescriptionNotIn        []string `json:"descriptionNotIn,omitempty"`
	DescriptionGT           *string  `json:"descriptionGT,omitempty"`
	DescriptionGTE          *string  `json:"descriptionGTE,omitempty"`
	DescriptionLT           *string  `json:"descriptionLT,omitempty"`
	DescriptionLTE          *string  `json:"descriptionLTE,omitempty"`
	DescriptionContains     *string  `json:"descriptionContains,omitempty"`
	DescriptionHasPrefix    *string  `json:"descriptionHasPrefix,omitempty"`
	DescriptionHasSuffix    *string  `json:"descriptionHasSuffix,omitempty"`
	DescriptionIsNil        bool     `json:"descriptionIsNil,omitempty"`
	DescriptionNotNil       bool     `json:"descriptionNotNil,omitempty"`
	DescriptionEqualFold    *string  `json:"descriptionEqualFold,omitempty"`
	DescriptionContainsFold *string  `json:"descriptionContainsFold,omitempty"`

	// "project" edge predicates.
	HasProject     *bool                `json:"hasProject,omitempty"`
	HasProjectWith []*ProjectWhereInput `json:"hasProjectWith,omitempty"`

	// "github_account" edge predicates.
	HasGithubAccount     *bool                      `json:"hasGithubAccount,omitempty"`
	HasGithubAccountWith []*GithubAccountWhereInput `json:"hasGithubAccountWith,omitempty"`

	// "github_organization" edge predicates.
	HasGithubOrganization     *bool                           `json:"hasGithubOrganization,omitempty"`
	HasGithubOrganizationWith []*GithubOrganizationWhereInput `json:"hasGithubOrganizationWith,omitempty"`

	// "discord_bots" edge predicates.
	HasDiscordBots     *bool                   `json:"hasDiscordBots,omitempty"`
	HasDiscordBotsWith []*DiscordBotWhereInput `json:"hasDiscordBotsWith,omitempty"`

	// "sites" edge predicates.
	HasSites     *bool             `json:"hasSites,omitempty"`
	HasSitesWith []*SiteWhereInput `json:"hasSitesWith,omitempty"`

	// "technologies" edge predicates.
	HasTechnologies     *bool                             `json:"hasTechnologies,omitempty"`
	HasTechnologiesWith []*RepositoryTechnologyWhereInput `json:"hasTechnologiesWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *RepositoryWhereInput) AddPredicates(predicates ...predicate.Repository) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the RepositoryWhereInput filter on the RepositoryQuery builder.
func (i *RepositoryWhereInput) Filter(q *RepositoryQuery) (*RepositoryQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyRepositoryWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyRepositoryWhereInput is returned in case the RepositoryWhereInput is empty.
var ErrEmptyRepositoryWhereInput = errors.New("ent: empty predicate RepositoryWhereInput")

// P returns a predicate for filtering repositories.
// An error is returned if the input is empty or invalid.
func (i *RepositoryWhereInput) P() (predicate.Repository, error) {
	var predicates []predicate.Repository
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, repository.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.Repository, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, repository.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.Repository, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, repository.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, repository.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, repository.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, repository.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, repository.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, repository.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, repository.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, repository.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, repository.IDLTE(*i.IDLTE))
	}
	if i.Name != nil {
		predicates = append(predicates, repository.NameEQ(*i.Name))
	}
	if i.NameNEQ != nil {
		predicates = append(predicates, repository.NameNEQ(*i.NameNEQ))
	}
	if len(i.NameIn) > 0 {
		predicates = append(predicates, repository.NameIn(i.NameIn...))
	}
	if len(i.NameNotIn) > 0 {
		predicates = append(predicates, repository.NameNotIn(i.NameNotIn...))
	}
	if i.NameGT != nil {
		predicates = append(predicates, repository.NameGT(*i.NameGT))
	}
	if i.NameGTE != nil {
		predicates = append(predicates, repository.NameGTE(*i.NameGTE))
	}
	if i.NameLT != nil {
		predicates = append(predicates, repository.NameLT(*i.NameLT))
	}
	if i.NameLTE != nil {
		predicates = append(predicates, repository.NameLTE(*i.NameLTE))
	}
	if i.NameContains != nil {
		predicates = append(predicates, repository.NameContains(*i.NameContains))
	}
	if i.NameHasPrefix != nil {
		predicates = append(predicates, repository.NameHasPrefix(*i.NameHasPrefix))
	}
	if i.NameHasSuffix != nil {
		predicates = append(predicates, repository.NameHasSuffix(*i.NameHasSuffix))
	}
	if i.NameEqualFold != nil {
		predicates = append(predicates, repository.NameEqualFold(*i.NameEqualFold))
	}
	if i.NameContainsFold != nil {
		predicates = append(predicates, repository.NameContainsFold(*i.NameContainsFold))
	}
	if i.Description != nil {
		predicates = append(predicates, repository.DescriptionEQ(*i.Description))
	}
	if i.DescriptionNEQ != nil {
		predicates = append(predicates, repository.DescriptionNEQ(*i.DescriptionNEQ))
	}
	if len(i.DescriptionIn) > 0 {
		predicates = append(predicates, repository.DescriptionIn(i.DescriptionIn...))
	}
	if len(i.DescriptionNotIn) > 0 {
		predicates = append(predicates, repository.DescriptionNotIn(i.DescriptionNotIn...))
	}
	if i.DescriptionGT != nil {
		predicates = append(predicates, repository.DescriptionGT(*i.DescriptionGT))
	}
	if i.DescriptionGTE != nil {
		predicates = append(predicates, repository.DescriptionGTE(*i.DescriptionGTE))
	}
	if i.DescriptionLT != nil {
		predicates = append(predicates, repository.DescriptionLT(*i.DescriptionLT))
	}
	if i.DescriptionLTE != nil {
		predicates = append(predicates, repository.DescriptionLTE(*i.DescriptionLTE))
	}
	if i.DescriptionContains != nil {
		predicates = append(predicates, repository.DescriptionContains(*i.DescriptionContains))
	}
	if i.DescriptionHasPrefix != nil {
		predicates = append(predicates, repository.DescriptionHasPrefix(*i.DescriptionHasPrefix))
	}
	if i.DescriptionHasSuffix != nil {
		predicates = append(predicates, repository.DescriptionHasSuffix(*i.DescriptionHasSuffix))
	}
	if i.DescriptionIsNil {
		predicates = append(predicates, repository.DescriptionIsNil())
	}
	if i.DescriptionNotNil {
		predicates = append(predicates, repository.DescriptionNotNil())
	}
	if i.DescriptionEqualFold != nil {
		predicates = append(predicates, repository.DescriptionEqualFold(*i.DescriptionEqualFold))
	}
	if i.DescriptionContainsFold != nil {
		predicates = append(predicates, repository.DescriptionContainsFold(*i.DescriptionContainsFold))
	}

	if i.HasProject != nil {
		p := repository.HasProject()
		if !*i.HasProject {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasProjectWith))
		for _, w := range i.HasProjectWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasProjectWith(with...))
	}
	if i.HasGithubAccount != nil {
		p := repository.HasGithubAccount()
		if !*i.HasGithubAccount {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasGithubAccountWith) > 0 {
		with := make([]predicate.GithubAccount, 0, len(i.HasGithubAccountWith))
		for _, w := range i.HasGithubAccountWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasGithubAccountWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasGithubAccountWith(with...))
	}
	if i.HasGithubOrganization != nil {
		p := repository.HasGithubOrganization()
		if !*i.HasGithubOrganization {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasGithubOrganizationWith) > 0 {
		with := make([]predicate.GithubOrganization, 0, len(i.HasGithubOrganizationWith))
		for _, w := range i.HasGithubOrganizationWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasGithubOrganizationWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasGithubOrganizationWith(with...))
	}
	if i.HasDiscordBots != nil {
		p := repository.HasDiscordBots()
		if !*i.HasDiscordBots {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasDiscordBotsWith) > 0 {
		with := make([]predicate.DiscordBot, 0, len(i.HasDiscordBotsWith))
		for _, w := range i.HasDiscordBotsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasDiscordBotsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasDiscordBotsWith(with...))
	}
	if i.HasSites != nil {
		p := repository.HasSites()
		if !*i.HasSites {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasSitesWith) > 0 {
		with := make([]predicate.Site, 0, len(i.HasSitesWith))
		for _, w := range i.HasSitesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasSitesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasSitesWith(with...))
	}
	if i.HasTechnologies != nil {
		p := repository.HasTechnologies()
		if !*i.HasTechnologies {
			p = repository.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasTechnologiesWith) > 0 {
		with := make([]predicate.RepositoryTechnology, 0, len(i.HasTechnologiesWith))
		for _, w := range i.HasTechnologiesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasTechnologiesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repository.HasTechnologiesWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyRepositoryWhereInput
	case 1:
		return predicates[0], nil
	default:
		return repository.And(predicates...), nil
	}
}

// RepositoryTechnologyWhereInput represents a where input for filtering RepositoryTechnology queries.
type RepositoryTechnologyWhereInput struct {
	Predicates []predicate.RepositoryTechnology  `json:"-"`
	Not        *RepositoryTechnologyWhereInput   `json:"not,omitempty"`
	Or         []*RepositoryTechnologyWhereInput `json:"or,omitempty"`
	And        []*RepositoryTechnologyWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "type" field predicates.
	Type      *repositorytechnology.Type  `json:"type,omitempty"`
	TypeNEQ   *repositorytechnology.Type  `json:"typeNEQ,omitempty"`
	TypeIn    []repositorytechnology.Type `json:"typeIn,omitempty"`
	TypeNotIn []repositorytechnology.Type `json:"typeNotIn,omitempty"`

	// "repository" edge predicates.
	HasRepository     *bool                   `json:"hasRepository,omitempty"`
	HasRepositoryWith []*RepositoryWhereInput `json:"hasRepositoryWith,omitempty"`

	// "technology" edge predicates.
	HasTechnology     *bool                   `json:"hasTechnology,omitempty"`
	HasTechnologyWith []*TechnologyWhereInput `json:"hasTechnologyWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *RepositoryTechnologyWhereInput) AddPredicates(predicates ...predicate.RepositoryTechnology) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the RepositoryTechnologyWhereInput filter on the RepositoryTechnologyQuery builder.
func (i *RepositoryTechnologyWhereInput) Filter(q *RepositoryTechnologyQuery) (*RepositoryTechnologyQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyRepositoryTechnologyWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyRepositoryTechnologyWhereInput is returned in case the RepositoryTechnologyWhereInput is empty.
var ErrEmptyRepositoryTechnologyWhereInput = errors.New("ent: empty predicate RepositoryTechnologyWhereInput")

// P returns a predicate for filtering repositorytechnologies.
// An error is returned if the input is empty or invalid.
func (i *RepositoryTechnologyWhereInput) P() (predicate.RepositoryTechnology, error) {
	var predicates []predicate.RepositoryTechnology
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, repositorytechnology.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.RepositoryTechnology, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, repositorytechnology.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.RepositoryTechnology, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, repositorytechnology.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, repositorytechnology.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, repositorytechnology.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, repositorytechnology.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, repositorytechnology.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, repositorytechnology.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, repositorytechnology.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, repositorytechnology.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, repositorytechnology.IDLTE(*i.IDLTE))
	}
	if i.Type != nil {
		predicates = append(predicates, repositorytechnology.TypeEQ(*i.Type))
	}
	if i.TypeNEQ != nil {
		predicates = append(predicates, repositorytechnology.TypeNEQ(*i.TypeNEQ))
	}
	if len(i.TypeIn) > 0 {
		predicates = append(predicates, repositorytechnology.TypeIn(i.TypeIn...))
	}
	if len(i.TypeNotIn) > 0 {
		predicates = append(predicates, repositorytechnology.TypeNotIn(i.TypeNotIn...))
	}

	if i.HasRepository != nil {
		p := repositorytechnology.HasRepository()
		if !*i.HasRepository {
			p = repositorytechnology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoryWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoryWith))
		for _, w := range i.HasRepositoryWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoryWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repositorytechnology.HasRepositoryWith(with...))
	}
	if i.HasTechnology != nil {
		p := repositorytechnology.HasTechnology()
		if !*i.HasTechnology {
			p = repositorytechnology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasTechnologyWith) > 0 {
		with := make([]predicate.Technology, 0, len(i.HasTechnologyWith))
		for _, w := range i.HasTechnologyWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasTechnologyWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, repositorytechnology.HasTechnologyWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyRepositoryTechnologyWhereInput
	case 1:
		return predicates[0], nil
	default:
		return repositorytechnology.And(predicates...), nil
	}
}

// SiteWhereInput represents a where input for filtering Site queries.
type SiteWhereInput struct {
	Predicates []predicate.Site  `json:"-"`
	Not        *SiteWhereInput   `json:"not,omitempty"`
	Or         []*SiteWhereInput `json:"or,omitempty"`
	And        []*SiteWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "url" field predicates.
	URL             *string  `json:"url,omitempty"`
	URLNEQ          *string  `json:"urlNEQ,omitempty"`
	URLIn           []string `json:"urlIn,omitempty"`
	URLNotIn        []string `json:"urlNotIn,omitempty"`
	URLGT           *string  `json:"urlGT,omitempty"`
	URLGTE          *string  `json:"urlGTE,omitempty"`
	URLLT           *string  `json:"urlLT,omitempty"`
	URLLTE          *string  `json:"urlLTE,omitempty"`
	URLContains     *string  `json:"urlContains,omitempty"`
	URLHasPrefix    *string  `json:"urlHasPrefix,omitempty"`
	URLHasSuffix    *string  `json:"urlHasSuffix,omitempty"`
	URLEqualFold    *string  `json:"urlEqualFold,omitempty"`
	URLContainsFold *string  `json:"urlContainsFold,omitempty"`

	// "project" edge predicates.
	HasProject     *bool                `json:"hasProject,omitempty"`
	HasProjectWith []*ProjectWhereInput `json:"hasProjectWith,omitempty"`

	// "repository" edge predicates.
	HasRepository     *bool                   `json:"hasRepository,omitempty"`
	HasRepositoryWith []*RepositoryWhereInput `json:"hasRepositoryWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *SiteWhereInput) AddPredicates(predicates ...predicate.Site) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the SiteWhereInput filter on the SiteQuery builder.
func (i *SiteWhereInput) Filter(q *SiteQuery) (*SiteQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptySiteWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptySiteWhereInput is returned in case the SiteWhereInput is empty.
var ErrEmptySiteWhereInput = errors.New("ent: empty predicate SiteWhereInput")

// P returns a predicate for filtering sites.
// An error is returned if the input is empty or invalid.
func (i *SiteWhereInput) P() (predicate.Site, error) {
	var predicates []predicate.Site
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, site.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.Site, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, site.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.Site, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, site.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, site.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, site.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, site.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, site.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, site.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, site.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, site.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, site.IDLTE(*i.IDLTE))
	}
	if i.URL != nil {
		predicates = append(predicates, site.URLEQ(*i.URL))
	}
	if i.URLNEQ != nil {
		predicates = append(predicates, site.URLNEQ(*i.URLNEQ))
	}
	if len(i.URLIn) > 0 {
		predicates = append(predicates, site.URLIn(i.URLIn...))
	}
	if len(i.URLNotIn) > 0 {
		predicates = append(predicates, site.URLNotIn(i.URLNotIn...))
	}
	if i.URLGT != nil {
		predicates = append(predicates, site.URLGT(*i.URLGT))
	}
	if i.URLGTE != nil {
		predicates = append(predicates, site.URLGTE(*i.URLGTE))
	}
	if i.URLLT != nil {
		predicates = append(predicates, site.URLLT(*i.URLLT))
	}
	if i.URLLTE != nil {
		predicates = append(predicates, site.URLLTE(*i.URLLTE))
	}
	if i.URLContains != nil {
		predicates = append(predicates, site.URLContains(*i.URLContains))
	}
	if i.URLHasPrefix != nil {
		predicates = append(predicates, site.URLHasPrefix(*i.URLHasPrefix))
	}
	if i.URLHasSuffix != nil {
		predicates = append(predicates, site.URLHasSuffix(*i.URLHasSuffix))
	}
	if i.URLEqualFold != nil {
		predicates = append(predicates, site.URLEqualFold(*i.URLEqualFold))
	}
	if i.URLContainsFold != nil {
		predicates = append(predicates, site.URLContainsFold(*i.URLContainsFold))
	}

	if i.HasProject != nil {
		p := site.HasProject()
		if !*i.HasProject {
			p = site.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectWith) > 0 {
		with := make([]predicate.Project, 0, len(i.HasProjectWith))
		for _, w := range i.HasProjectWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, site.HasProjectWith(with...))
	}
	if i.HasRepository != nil {
		p := site.HasRepository()
		if !*i.HasRepository {
			p = site.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoryWith) > 0 {
		with := make([]predicate.Repository, 0, len(i.HasRepositoryWith))
		for _, w := range i.HasRepositoryWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoryWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, site.HasRepositoryWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptySiteWhereInput
	case 1:
		return predicates[0], nil
	default:
		return site.And(predicates...), nil
	}
}

// TechnologyWhereInput represents a where input for filtering Technology queries.
type TechnologyWhereInput struct {
	Predicates []predicate.Technology  `json:"-"`
	Not        *TechnologyWhereInput   `json:"not,omitempty"`
	Or         []*TechnologyWhereInput `json:"or,omitempty"`
	And        []*TechnologyWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "name" field predicates.
	Name             *string  `json:"name,omitempty"`
	NameNEQ          *string  `json:"nameNEQ,omitempty"`
	NameIn           []string `json:"nameIn,omitempty"`
	NameNotIn        []string `json:"nameNotIn,omitempty"`
	NameGT           *string  `json:"nameGT,omitempty"`
	NameGTE          *string  `json:"nameGTE,omitempty"`
	NameLT           *string  `json:"nameLT,omitempty"`
	NameLTE          *string  `json:"nameLTE,omitempty"`
	NameContains     *string  `json:"nameContains,omitempty"`
	NameHasPrefix    *string  `json:"nameHasPrefix,omitempty"`
	NameHasSuffix    *string  `json:"nameHasSuffix,omitempty"`
	NameEqualFold    *string  `json:"nameEqualFold,omitempty"`
	NameContainsFold *string  `json:"nameContainsFold,omitempty"`

	// "description" field predicates.
	Description             *string  `json:"description,omitempty"`
	DescriptionNEQ          *string  `json:"descriptionNEQ,omitempty"`
	DescriptionIn           []string `json:"descriptionIn,omitempty"`
	DescriptionNotIn        []string `json:"descriptionNotIn,omitempty"`
	DescriptionGT           *string  `json:"descriptionGT,omitempty"`
	DescriptionGTE          *string  `json:"descriptionGTE,omitempty"`
	DescriptionLT           *string  `json:"descriptionLT,omitempty"`
	DescriptionLTE          *string  `json:"descriptionLTE,omitempty"`
	DescriptionContains     *string  `json:"descriptionContains,omitempty"`
	DescriptionHasPrefix    *string  `json:"descriptionHasPrefix,omitempty"`
	DescriptionHasSuffix    *string  `json:"descriptionHasSuffix,omitempty"`
	DescriptionIsNil        bool     `json:"descriptionIsNil,omitempty"`
	DescriptionNotNil       bool     `json:"descriptionNotNil,omitempty"`
	DescriptionEqualFold    *string  `json:"descriptionEqualFold,omitempty"`
	DescriptionContainsFold *string  `json:"descriptionContainsFold,omitempty"`

	// "colour" field predicates.
	Colour             *string  `json:"colour,omitempty"`
	ColourNEQ          *string  `json:"colourNEQ,omitempty"`
	ColourIn           []string `json:"colourIn,omitempty"`
	ColourNotIn        []string `json:"colourNotIn,omitempty"`
	ColourGT           *string  `json:"colourGT,omitempty"`
	ColourGTE          *string  `json:"colourGTE,omitempty"`
	ColourLT           *string  `json:"colourLT,omitempty"`
	ColourLTE          *string  `json:"colourLTE,omitempty"`
	ColourContains     *string  `json:"colourContains,omitempty"`
	ColourHasPrefix    *string  `json:"colourHasPrefix,omitempty"`
	ColourHasSuffix    *string  `json:"colourHasSuffix,omitempty"`
	ColourIsNil        bool     `json:"colourIsNil,omitempty"`
	ColourNotNil       bool     `json:"colourNotNil,omitempty"`
	ColourEqualFold    *string  `json:"colourEqualFold,omitempty"`
	ColourContainsFold *string  `json:"colourContainsFold,omitempty"`

	// "type" field predicates.
	Type      *technology.Type  `json:"type,omitempty"`
	TypeNEQ   *technology.Type  `json:"typeNEQ,omitempty"`
	TypeIn    []technology.Type `json:"typeIn,omitempty"`
	TypeNotIn []technology.Type `json:"typeNotIn,omitempty"`

	// "parent_technologies" edge predicates.
	HasParentTechnologies     *bool                              `json:"hasParentTechnologies,omitempty"`
	HasParentTechnologiesWith []*TechnologyAssociationWhereInput `json:"hasParentTechnologiesWith,omitempty"`

	// "child_technologies" edge predicates.
	HasChildTechnologies     *bool                              `json:"hasChildTechnologies,omitempty"`
	HasChildTechnologiesWith []*TechnologyAssociationWhereInput `json:"hasChildTechnologiesWith,omitempty"`

	// "projects" edge predicates.
	HasProjects     *bool                          `json:"hasProjects,omitempty"`
	HasProjectsWith []*ProjectTechnologyWhereInput `json:"hasProjectsWith,omitempty"`

	// "repositories" edge predicates.
	HasRepositories     *bool                             `json:"hasRepositories,omitempty"`
	HasRepositoriesWith []*RepositoryTechnologyWhereInput `json:"hasRepositoriesWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *TechnologyWhereInput) AddPredicates(predicates ...predicate.Technology) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the TechnologyWhereInput filter on the TechnologyQuery builder.
func (i *TechnologyWhereInput) Filter(q *TechnologyQuery) (*TechnologyQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyTechnologyWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyTechnologyWhereInput is returned in case the TechnologyWhereInput is empty.
var ErrEmptyTechnologyWhereInput = errors.New("ent: empty predicate TechnologyWhereInput")

// P returns a predicate for filtering technologies.
// An error is returned if the input is empty or invalid.
func (i *TechnologyWhereInput) P() (predicate.Technology, error) {
	var predicates []predicate.Technology
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, technology.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.Technology, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, technology.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.Technology, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, technology.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, technology.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, technology.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, technology.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, technology.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, technology.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, technology.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, technology.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, technology.IDLTE(*i.IDLTE))
	}
	if i.Name != nil {
		predicates = append(predicates, technology.NameEQ(*i.Name))
	}
	if i.NameNEQ != nil {
		predicates = append(predicates, technology.NameNEQ(*i.NameNEQ))
	}
	if len(i.NameIn) > 0 {
		predicates = append(predicates, technology.NameIn(i.NameIn...))
	}
	if len(i.NameNotIn) > 0 {
		predicates = append(predicates, technology.NameNotIn(i.NameNotIn...))
	}
	if i.NameGT != nil {
		predicates = append(predicates, technology.NameGT(*i.NameGT))
	}
	if i.NameGTE != nil {
		predicates = append(predicates, technology.NameGTE(*i.NameGTE))
	}
	if i.NameLT != nil {
		predicates = append(predicates, technology.NameLT(*i.NameLT))
	}
	if i.NameLTE != nil {
		predicates = append(predicates, technology.NameLTE(*i.NameLTE))
	}
	if i.NameContains != nil {
		predicates = append(predicates, technology.NameContains(*i.NameContains))
	}
	if i.NameHasPrefix != nil {
		predicates = append(predicates, technology.NameHasPrefix(*i.NameHasPrefix))
	}
	if i.NameHasSuffix != nil {
		predicates = append(predicates, technology.NameHasSuffix(*i.NameHasSuffix))
	}
	if i.NameEqualFold != nil {
		predicates = append(predicates, technology.NameEqualFold(*i.NameEqualFold))
	}
	if i.NameContainsFold != nil {
		predicates = append(predicates, technology.NameContainsFold(*i.NameContainsFold))
	}
	if i.Description != nil {
		predicates = append(predicates, technology.DescriptionEQ(*i.Description))
	}
	if i.DescriptionNEQ != nil {
		predicates = append(predicates, technology.DescriptionNEQ(*i.DescriptionNEQ))
	}
	if len(i.DescriptionIn) > 0 {
		predicates = append(predicates, technology.DescriptionIn(i.DescriptionIn...))
	}
	if len(i.DescriptionNotIn) > 0 {
		predicates = append(predicates, technology.DescriptionNotIn(i.DescriptionNotIn...))
	}
	if i.DescriptionGT != nil {
		predicates = append(predicates, technology.DescriptionGT(*i.DescriptionGT))
	}
	if i.DescriptionGTE != nil {
		predicates = append(predicates, technology.DescriptionGTE(*i.DescriptionGTE))
	}
	if i.DescriptionLT != nil {
		predicates = append(predicates, technology.DescriptionLT(*i.DescriptionLT))
	}
	if i.DescriptionLTE != nil {
		predicates = append(predicates, technology.DescriptionLTE(*i.DescriptionLTE))
	}
	if i.DescriptionContains != nil {
		predicates = append(predicates, technology.DescriptionContains(*i.DescriptionContains))
	}
	if i.DescriptionHasPrefix != nil {
		predicates = append(predicates, technology.DescriptionHasPrefix(*i.DescriptionHasPrefix))
	}
	if i.DescriptionHasSuffix != nil {
		predicates = append(predicates, technology.DescriptionHasSuffix(*i.DescriptionHasSuffix))
	}
	if i.DescriptionIsNil {
		predicates = append(predicates, technology.DescriptionIsNil())
	}
	if i.DescriptionNotNil {
		predicates = append(predicates, technology.DescriptionNotNil())
	}
	if i.DescriptionEqualFold != nil {
		predicates = append(predicates, technology.DescriptionEqualFold(*i.DescriptionEqualFold))
	}
	if i.DescriptionContainsFold != nil {
		predicates = append(predicates, technology.DescriptionContainsFold(*i.DescriptionContainsFold))
	}
	if i.Colour != nil {
		predicates = append(predicates, technology.ColourEQ(*i.Colour))
	}
	if i.ColourNEQ != nil {
		predicates = append(predicates, technology.ColourNEQ(*i.ColourNEQ))
	}
	if len(i.ColourIn) > 0 {
		predicates = append(predicates, technology.ColourIn(i.ColourIn...))
	}
	if len(i.ColourNotIn) > 0 {
		predicates = append(predicates, technology.ColourNotIn(i.ColourNotIn...))
	}
	if i.ColourGT != nil {
		predicates = append(predicates, technology.ColourGT(*i.ColourGT))
	}
	if i.ColourGTE != nil {
		predicates = append(predicates, technology.ColourGTE(*i.ColourGTE))
	}
	if i.ColourLT != nil {
		predicates = append(predicates, technology.ColourLT(*i.ColourLT))
	}
	if i.ColourLTE != nil {
		predicates = append(predicates, technology.ColourLTE(*i.ColourLTE))
	}
	if i.ColourContains != nil {
		predicates = append(predicates, technology.ColourContains(*i.ColourContains))
	}
	if i.ColourHasPrefix != nil {
		predicates = append(predicates, technology.ColourHasPrefix(*i.ColourHasPrefix))
	}
	if i.ColourHasSuffix != nil {
		predicates = append(predicates, technology.ColourHasSuffix(*i.ColourHasSuffix))
	}
	if i.ColourIsNil {
		predicates = append(predicates, technology.ColourIsNil())
	}
	if i.ColourNotNil {
		predicates = append(predicates, technology.ColourNotNil())
	}
	if i.ColourEqualFold != nil {
		predicates = append(predicates, technology.ColourEqualFold(*i.ColourEqualFold))
	}
	if i.ColourContainsFold != nil {
		predicates = append(predicates, technology.ColourContainsFold(*i.ColourContainsFold))
	}
	if i.Type != nil {
		predicates = append(predicates, technology.TypeEQ(*i.Type))
	}
	if i.TypeNEQ != nil {
		predicates = append(predicates, technology.TypeNEQ(*i.TypeNEQ))
	}
	if len(i.TypeIn) > 0 {
		predicates = append(predicates, technology.TypeIn(i.TypeIn...))
	}
	if len(i.TypeNotIn) > 0 {
		predicates = append(predicates, technology.TypeNotIn(i.TypeNotIn...))
	}

	if i.HasParentTechnologies != nil {
		p := technology.HasParentTechnologies()
		if !*i.HasParentTechnologies {
			p = technology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasParentTechnologiesWith) > 0 {
		with := make([]predicate.TechnologyAssociation, 0, len(i.HasParentTechnologiesWith))
		for _, w := range i.HasParentTechnologiesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasParentTechnologiesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technology.HasParentTechnologiesWith(with...))
	}
	if i.HasChildTechnologies != nil {
		p := technology.HasChildTechnologies()
		if !*i.HasChildTechnologies {
			p = technology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasChildTechnologiesWith) > 0 {
		with := make([]predicate.TechnologyAssociation, 0, len(i.HasChildTechnologiesWith))
		for _, w := range i.HasChildTechnologiesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasChildTechnologiesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technology.HasChildTechnologiesWith(with...))
	}
	if i.HasProjects != nil {
		p := technology.HasProjects()
		if !*i.HasProjects {
			p = technology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectsWith) > 0 {
		with := make([]predicate.ProjectTechnology, 0, len(i.HasProjectsWith))
		for _, w := range i.HasProjectsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technology.HasProjectsWith(with...))
	}
	if i.HasRepositories != nil {
		p := technology.HasRepositories()
		if !*i.HasRepositories {
			p = technology.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasRepositoriesWith) > 0 {
		with := make([]predicate.RepositoryTechnology, 0, len(i.HasRepositoriesWith))
		for _, w := range i.HasRepositoriesWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasRepositoriesWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technology.HasRepositoriesWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyTechnologyWhereInput
	case 1:
		return predicates[0], nil
	default:
		return technology.And(predicates...), nil
	}
}

// TechnologyAssociationWhereInput represents a where input for filtering TechnologyAssociation queries.
type TechnologyAssociationWhereInput struct {
	Predicates []predicate.TechnologyAssociation  `json:"-"`
	Not        *TechnologyAssociationWhereInput   `json:"not,omitempty"`
	Or         []*TechnologyAssociationWhereInput `json:"or,omitempty"`
	And        []*TechnologyAssociationWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "type" field predicates.
	Type      *technologyassociation.Type  `json:"type,omitempty"`
	TypeNEQ   *technologyassociation.Type  `json:"typeNEQ,omitempty"`
	TypeIn    []technologyassociation.Type `json:"typeIn,omitempty"`
	TypeNotIn []technologyassociation.Type `json:"typeNotIn,omitempty"`

	// "parent" edge predicates.
	HasParent     *bool                   `json:"hasParent,omitempty"`
	HasParentWith []*TechnologyWhereInput `json:"hasParentWith,omitempty"`

	// "child" edge predicates.
	HasChild     *bool                   `json:"hasChild,omitempty"`
	HasChildWith []*TechnologyWhereInput `json:"hasChildWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *TechnologyAssociationWhereInput) AddPredicates(predicates ...predicate.TechnologyAssociation) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the TechnologyAssociationWhereInput filter on the TechnologyAssociationQuery builder.
func (i *TechnologyAssociationWhereInput) Filter(q *TechnologyAssociationQuery) (*TechnologyAssociationQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyTechnologyAssociationWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyTechnologyAssociationWhereInput is returned in case the TechnologyAssociationWhereInput is empty.
var ErrEmptyTechnologyAssociationWhereInput = errors.New("ent: empty predicate TechnologyAssociationWhereInput")

// P returns a predicate for filtering technologyassociations.
// An error is returned if the input is empty or invalid.
func (i *TechnologyAssociationWhereInput) P() (predicate.TechnologyAssociation, error) {
	var predicates []predicate.TechnologyAssociation
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, technologyassociation.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.TechnologyAssociation, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, technologyassociation.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.TechnologyAssociation, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, technologyassociation.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, technologyassociation.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, technologyassociation.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, technologyassociation.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, technologyassociation.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, technologyassociation.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, technologyassociation.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, technologyassociation.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, technologyassociation.IDLTE(*i.IDLTE))
	}
	if i.Type != nil {
		predicates = append(predicates, technologyassociation.TypeEQ(*i.Type))
	}
	if i.TypeNEQ != nil {
		predicates = append(predicates, technologyassociation.TypeNEQ(*i.TypeNEQ))
	}
	if len(i.TypeIn) > 0 {
		predicates = append(predicates, technologyassociation.TypeIn(i.TypeIn...))
	}
	if len(i.TypeNotIn) > 0 {
		predicates = append(predicates, technologyassociation.TypeNotIn(i.TypeNotIn...))
	}

	if i.HasParent != nil {
		p := technologyassociation.HasParent()
		if !*i.HasParent {
			p = technologyassociation.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasParentWith) > 0 {
		with := make([]predicate.Technology, 0, len(i.HasParentWith))
		for _, w := range i.HasParentWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasParentWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technologyassociation.HasParentWith(with...))
	}
	if i.HasChild != nil {
		p := technologyassociation.HasChild()
		if !*i.HasChild {
			p = technologyassociation.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasChildWith) > 0 {
		with := make([]predicate.Technology, 0, len(i.HasChildWith))
		for _, w := range i.HasChildWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasChildWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, technologyassociation.HasChildWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyTechnologyAssociationWhereInput
	case 1:
		return predicates[0], nil
	default:
		return technologyassociation.And(predicates...), nil
	}
}

// UserWhereInput represents a where input for filtering User queries.
type UserWhereInput struct {
	Predicates []predicate.User  `json:"-"`
	Not        *UserWhereInput   `json:"not,omitempty"`
	Or         []*UserWhereInput `json:"or,omitempty"`
	And        []*UserWhereInput `json:"and,omitempty"`

	// "id" field predicates.
	ID      *int  `json:"id,omitempty"`
	IDNEQ   *int  `json:"idNEQ,omitempty"`
	IDIn    []int `json:"idIn,omitempty"`
	IDNotIn []int `json:"idNotIn,omitempty"`
	IDGT    *int  `json:"idGT,omitempty"`
	IDGTE   *int  `json:"idGTE,omitempty"`
	IDLT    *int  `json:"idLT,omitempty"`
	IDLTE   *int  `json:"idLTE,omitempty"`

	// "username" field predicates.
	Username             *string  `json:"username,omitempty"`
	UsernameNEQ          *string  `json:"usernameNEQ,omitempty"`
	UsernameIn           []string `json:"usernameIn,omitempty"`
	UsernameNotIn        []string `json:"usernameNotIn,omitempty"`
	UsernameGT           *string  `json:"usernameGT,omitempty"`
	UsernameGTE          *string  `json:"usernameGTE,omitempty"`
	UsernameLT           *string  `json:"usernameLT,omitempty"`
	UsernameLTE          *string  `json:"usernameLTE,omitempty"`
	UsernameContains     *string  `json:"usernameContains,omitempty"`
	UsernameHasPrefix    *string  `json:"usernameHasPrefix,omitempty"`
	UsernameHasSuffix    *string  `json:"usernameHasSuffix,omitempty"`
	UsernameEqualFold    *string  `json:"usernameEqualFold,omitempty"`
	UsernameContainsFold *string  `json:"usernameContainsFold,omitempty"`

	// "avatar_url" field predicates.
	AvatarURL             *string  `json:"avatarURL,omitempty"`
	AvatarURLNEQ          *string  `json:"avatarURLNEQ,omitempty"`
	AvatarURLIn           []string `json:"avatarURLIn,omitempty"`
	AvatarURLNotIn        []string `json:"avatarURLNotIn,omitempty"`
	AvatarURLGT           *string  `json:"avatarURLGT,omitempty"`
	AvatarURLGTE          *string  `json:"avatarURLGTE,omitempty"`
	AvatarURLLT           *string  `json:"avatarURLLT,omitempty"`
	AvatarURLLTE          *string  `json:"avatarURLLTE,omitempty"`
	AvatarURLContains     *string  `json:"avatarURLContains,omitempty"`
	AvatarURLHasPrefix    *string  `json:"avatarURLHasPrefix,omitempty"`
	AvatarURLHasSuffix    *string  `json:"avatarURLHasSuffix,omitempty"`
	AvatarURLIsNil        bool     `json:"avatarURLIsNil,omitempty"`
	AvatarURLNotNil       bool     `json:"avatarURLNotNil,omitempty"`
	AvatarURLEqualFold    *string  `json:"avatarURLEqualFold,omitempty"`
	AvatarURLContainsFold *string  `json:"avatarURLContainsFold,omitempty"`

	// "discord_accounts" edge predicates.
	HasDiscordAccounts     *bool                       `json:"hasDiscordAccounts,omitempty"`
	HasDiscordAccountsWith []*DiscordAccountWhereInput `json:"hasDiscordAccountsWith,omitempty"`

	// "github_accounts" edge predicates.
	HasGithubAccounts     *bool                      `json:"hasGithubAccounts,omitempty"`
	HasGithubAccountsWith []*GithubAccountWhereInput `json:"hasGithubAccountsWith,omitempty"`

	// "project_contributions" edge predicates.
	HasProjectContributions     *bool                           `json:"hasProjectContributions,omitempty"`
	HasProjectContributionsWith []*ProjectContributorWhereInput `json:"hasProjectContributionsWith,omitempty"`
}

// AddPredicates adds custom predicates to the where input to be used during the filtering phase.
func (i *UserWhereInput) AddPredicates(predicates ...predicate.User) {
	i.Predicates = append(i.Predicates, predicates...)
}

// Filter applies the UserWhereInput filter on the UserQuery builder.
func (i *UserWhereInput) Filter(q *UserQuery) (*UserQuery, error) {
	if i == nil {
		return q, nil
	}
	p, err := i.P()
	if err != nil {
		if err == ErrEmptyUserWhereInput {
			return q, nil
		}
		return nil, err
	}
	return q.Where(p), nil
}

// ErrEmptyUserWhereInput is returned in case the UserWhereInput is empty.
var ErrEmptyUserWhereInput = errors.New("ent: empty predicate UserWhereInput")

// P returns a predicate for filtering users.
// An error is returned if the input is empty or invalid.
func (i *UserWhereInput) P() (predicate.User, error) {
	var predicates []predicate.User
	if i.Not != nil {
		p, err := i.Not.P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'not'", err)
		}
		predicates = append(predicates, user.Not(p))
	}
	switch n := len(i.Or); {
	case n == 1:
		p, err := i.Or[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'or'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		or := make([]predicate.User, 0, n)
		for _, w := range i.Or {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'or'", err)
			}
			or = append(or, p)
		}
		predicates = append(predicates, user.Or(or...))
	}
	switch n := len(i.And); {
	case n == 1:
		p, err := i.And[0].P()
		if err != nil {
			return nil, fmt.Errorf("%w: field 'and'", err)
		}
		predicates = append(predicates, p)
	case n > 1:
		and := make([]predicate.User, 0, n)
		for _, w := range i.And {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'and'", err)
			}
			and = append(and, p)
		}
		predicates = append(predicates, user.And(and...))
	}
	predicates = append(predicates, i.Predicates...)
	if i.ID != nil {
		predicates = append(predicates, user.IDEQ(*i.ID))
	}
	if i.IDNEQ != nil {
		predicates = append(predicates, user.IDNEQ(*i.IDNEQ))
	}
	if len(i.IDIn) > 0 {
		predicates = append(predicates, user.IDIn(i.IDIn...))
	}
	if len(i.IDNotIn) > 0 {
		predicates = append(predicates, user.IDNotIn(i.IDNotIn...))
	}
	if i.IDGT != nil {
		predicates = append(predicates, user.IDGT(*i.IDGT))
	}
	if i.IDGTE != nil {
		predicates = append(predicates, user.IDGTE(*i.IDGTE))
	}
	if i.IDLT != nil {
		predicates = append(predicates, user.IDLT(*i.IDLT))
	}
	if i.IDLTE != nil {
		predicates = append(predicates, user.IDLTE(*i.IDLTE))
	}
	if i.Username != nil {
		predicates = append(predicates, user.UsernameEQ(*i.Username))
	}
	if i.UsernameNEQ != nil {
		predicates = append(predicates, user.UsernameNEQ(*i.UsernameNEQ))
	}
	if len(i.UsernameIn) > 0 {
		predicates = append(predicates, user.UsernameIn(i.UsernameIn...))
	}
	if len(i.UsernameNotIn) > 0 {
		predicates = append(predicates, user.UsernameNotIn(i.UsernameNotIn...))
	}
	if i.UsernameGT != nil {
		predicates = append(predicates, user.UsernameGT(*i.UsernameGT))
	}
	if i.UsernameGTE != nil {
		predicates = append(predicates, user.UsernameGTE(*i.UsernameGTE))
	}
	if i.UsernameLT != nil {
		predicates = append(predicates, user.UsernameLT(*i.UsernameLT))
	}
	if i.UsernameLTE != nil {
		predicates = append(predicates, user.UsernameLTE(*i.UsernameLTE))
	}
	if i.UsernameContains != nil {
		predicates = append(predicates, user.UsernameContains(*i.UsernameContains))
	}
	if i.UsernameHasPrefix != nil {
		predicates = append(predicates, user.UsernameHasPrefix(*i.UsernameHasPrefix))
	}
	if i.UsernameHasSuffix != nil {
		predicates = append(predicates, user.UsernameHasSuffix(*i.UsernameHasSuffix))
	}
	if i.UsernameEqualFold != nil {
		predicates = append(predicates, user.UsernameEqualFold(*i.UsernameEqualFold))
	}
	if i.UsernameContainsFold != nil {
		predicates = append(predicates, user.UsernameContainsFold(*i.UsernameContainsFold))
	}
	if i.AvatarURL != nil {
		predicates = append(predicates, user.AvatarURLEQ(*i.AvatarURL))
	}
	if i.AvatarURLNEQ != nil {
		predicates = append(predicates, user.AvatarURLNEQ(*i.AvatarURLNEQ))
	}
	if len(i.AvatarURLIn) > 0 {
		predicates = append(predicates, user.AvatarURLIn(i.AvatarURLIn...))
	}
	if len(i.AvatarURLNotIn) > 0 {
		predicates = append(predicates, user.AvatarURLNotIn(i.AvatarURLNotIn...))
	}
	if i.AvatarURLGT != nil {
		predicates = append(predicates, user.AvatarURLGT(*i.AvatarURLGT))
	}
	if i.AvatarURLGTE != nil {
		predicates = append(predicates, user.AvatarURLGTE(*i.AvatarURLGTE))
	}
	if i.AvatarURLLT != nil {
		predicates = append(predicates, user.AvatarURLLT(*i.AvatarURLLT))
	}
	if i.AvatarURLLTE != nil {
		predicates = append(predicates, user.AvatarURLLTE(*i.AvatarURLLTE))
	}
	if i.AvatarURLContains != nil {
		predicates = append(predicates, user.AvatarURLContains(*i.AvatarURLContains))
	}
	if i.AvatarURLHasPrefix != nil {
		predicates = append(predicates, user.AvatarURLHasPrefix(*i.AvatarURLHasPrefix))
	}
	if i.AvatarURLHasSuffix != nil {
		predicates = append(predicates, user.AvatarURLHasSuffix(*i.AvatarURLHasSuffix))
	}
	if i.AvatarURLIsNil {
		predicates = append(predicates, user.AvatarURLIsNil())
	}
	if i.AvatarURLNotNil {
		predicates = append(predicates, user.AvatarURLNotNil())
	}
	if i.AvatarURLEqualFold != nil {
		predicates = append(predicates, user.AvatarURLEqualFold(*i.AvatarURLEqualFold))
	}
	if i.AvatarURLContainsFold != nil {
		predicates = append(predicates, user.AvatarURLContainsFold(*i.AvatarURLContainsFold))
	}

	if i.HasDiscordAccounts != nil {
		p := user.HasDiscordAccounts()
		if !*i.HasDiscordAccounts {
			p = user.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasDiscordAccountsWith) > 0 {
		with := make([]predicate.DiscordAccount, 0, len(i.HasDiscordAccountsWith))
		for _, w := range i.HasDiscordAccountsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasDiscordAccountsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, user.HasDiscordAccountsWith(with...))
	}
	if i.HasGithubAccounts != nil {
		p := user.HasGithubAccounts()
		if !*i.HasGithubAccounts {
			p = user.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasGithubAccountsWith) > 0 {
		with := make([]predicate.GithubAccount, 0, len(i.HasGithubAccountsWith))
		for _, w := range i.HasGithubAccountsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasGithubAccountsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, user.HasGithubAccountsWith(with...))
	}
	if i.HasProjectContributions != nil {
		p := user.HasProjectContributions()
		if !*i.HasProjectContributions {
			p = user.Not(p)
		}
		predicates = append(predicates, p)
	}
	if len(i.HasProjectContributionsWith) > 0 {
		with := make([]predicate.ProjectContributor, 0, len(i.HasProjectContributionsWith))
		for _, w := range i.HasProjectContributionsWith {
			p, err := w.P()
			if err != nil {
				return nil, fmt.Errorf("%w: field 'HasProjectContributionsWith'", err)
			}
			with = append(with, p)
		}
		predicates = append(predicates, user.HasProjectContributionsWith(with...))
	}
	switch len(predicates) {
	case 0:
		return nil, ErrEmptyUserWhereInput
	case 1:
		return predicates[0], nil
	default:
		return user.And(predicates...), nil
	}
}