client.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/fogo-sh/grackdb/ent/migrate"

	"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/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"

	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
)

// Client is the client that holds all ent builders.
type Client struct {
	config
	// Schema is the client for creating, migrating and dropping schema.
	Schema *migrate.Schema
	// DiscordAccount is the client for interacting with the DiscordAccount builders.
	DiscordAccount *DiscordAccountClient
	// DiscordBot is the client for interacting with the DiscordBot builders.
	DiscordBot *DiscordBotClient
	// GithubAccount is the client for interacting with the GithubAccount builders.
	GithubAccount *GithubAccountClient
	// GithubOrganization is the client for interacting with the GithubOrganization builders.
	GithubOrganization *GithubOrganizationClient
	// GithubOrganizationMember is the client for interacting with the GithubOrganizationMember builders.
	GithubOrganizationMember *GithubOrganizationMemberClient
	// Project is the client for interacting with the Project builders.
	Project *ProjectClient
	// ProjectAssociation is the client for interacting with the ProjectAssociation builders.
	ProjectAssociation *ProjectAssociationClient
	// ProjectContributor is the client for interacting with the ProjectContributor builders.
	ProjectContributor *ProjectContributorClient
	// ProjectTechnology is the client for interacting with the ProjectTechnology builders.
	ProjectTechnology *ProjectTechnologyClient
	// Repository is the client for interacting with the Repository builders.
	Repository *RepositoryClient
	// RepositoryTechnology is the client for interacting with the RepositoryTechnology builders.
	RepositoryTechnology *RepositoryTechnologyClient
	// Site is the client for interacting with the Site builders.
	Site *SiteClient
	// Technology is the client for interacting with the Technology builders.
	Technology *TechnologyClient
	// TechnologyAssociation is the client for interacting with the TechnologyAssociation builders.
	TechnologyAssociation *TechnologyAssociationClient
	// User is the client for interacting with the User builders.
	User *UserClient
	// additional fields for node api
	tables tables
}

// NewClient creates a new client configured with the given options.
func NewClient(opts ...Option) *Client {
	cfg := config{log: log.Println, hooks: &hooks{}}
	cfg.options(opts...)
	client := &Client{config: cfg}
	client.init()
	return client
}

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.DiscordAccount = NewDiscordAccountClient(c.config)
	c.DiscordBot = NewDiscordBotClient(c.config)
	c.GithubAccount = NewGithubAccountClient(c.config)
	c.GithubOrganization = NewGithubOrganizationClient(c.config)
	c.GithubOrganizationMember = NewGithubOrganizationMemberClient(c.config)
	c.Project = NewProjectClient(c.config)
	c.ProjectAssociation = NewProjectAssociationClient(c.config)
	c.ProjectContributor = NewProjectContributorClient(c.config)
	c.ProjectTechnology = NewProjectTechnologyClient(c.config)
	c.Repository = NewRepositoryClient(c.config)
	c.RepositoryTechnology = NewRepositoryTechnologyClient(c.config)
	c.Site = NewSiteClient(c.config)
	c.Technology = NewTechnologyClient(c.config)
	c.TechnologyAssociation = NewTechnologyAssociationClient(c.config)
	c.User = NewUserClient(c.config)
}

// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
	switch driverName {
	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
		drv, err := sql.Open(driverName, dataSourceName)
		if err != nil {
			return nil, err
		}
		return NewClient(append(options, Driver(drv))...), nil
	default:
		return nil, fmt.Errorf("unsupported driver: %q", driverName)
	}
}

// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := newTx(ctx, c.driver)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:                      ctx,
		config:                   cfg,
		DiscordAccount:           NewDiscordAccountClient(cfg),
		DiscordBot:               NewDiscordBotClient(cfg),
		GithubAccount:            NewGithubAccountClient(cfg),
		GithubOrganization:       NewGithubOrganizationClient(cfg),
		GithubOrganizationMember: NewGithubOrganizationMemberClient(cfg),
		Project:                  NewProjectClient(cfg),
		ProjectAssociation:       NewProjectAssociationClient(cfg),
		ProjectContributor:       NewProjectContributorClient(cfg),
		ProjectTechnology:        NewProjectTechnologyClient(cfg),
		Repository:               NewRepositoryClient(cfg),
		RepositoryTechnology:     NewRepositoryTechnologyClient(cfg),
		Site:                     NewSiteClient(cfg),
		Technology:               NewTechnologyClient(cfg),
		TechnologyAssociation:    NewTechnologyAssociationClient(cfg),
		User:                     NewUserClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := c.driver.(interface {
		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
	}).BeginTx(ctx, opts)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = &txDriver{tx: tx, drv: c.driver}
	return &Tx{
		ctx:                      ctx,
		config:                   cfg,
		DiscordAccount:           NewDiscordAccountClient(cfg),
		DiscordBot:               NewDiscordBotClient(cfg),
		GithubAccount:            NewGithubAccountClient(cfg),
		GithubOrganization:       NewGithubOrganizationClient(cfg),
		GithubOrganizationMember: NewGithubOrganizationMemberClient(cfg),
		Project:                  NewProjectClient(cfg),
		ProjectAssociation:       NewProjectAssociationClient(cfg),
		ProjectContributor:       NewProjectContributorClient(cfg),
		ProjectTechnology:        NewProjectTechnologyClient(cfg),
		Repository:               NewRepositoryClient(cfg),
		RepositoryTechnology:     NewRepositoryTechnologyClient(cfg),
		Site:                     NewSiteClient(cfg),
		Technology:               NewTechnologyClient(cfg),
		TechnologyAssociation:    NewTechnologyAssociationClient(cfg),
		User:                     NewUserClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		DiscordAccount.
//		Query().
//		Count(ctx)
func (c *Client) Debug() *Client {
	if c.debug {
		return c
	}
	cfg := c.config
	cfg.driver = dialect.Debug(c.driver, c.log)
	client := &Client{config: cfg}
	client.init()
	return client
}

// Close closes the database connection and prevents new queries from starting.
func (c *Client) Close() error {
	return c.driver.Close()
}

// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
	c.DiscordAccount.Use(hooks...)
	c.DiscordBot.Use(hooks...)
	c.GithubAccount.Use(hooks...)
	c.GithubOrganization.Use(hooks...)
	c.GithubOrganizationMember.Use(hooks...)
	c.Project.Use(hooks...)
	c.ProjectAssociation.Use(hooks...)
	c.ProjectContributor.Use(hooks...)
	c.ProjectTechnology.Use(hooks...)
	c.Repository.Use(hooks...)
	c.RepositoryTechnology.Use(hooks...)
	c.Site.Use(hooks...)
	c.Technology.Use(hooks...)
	c.TechnologyAssociation.Use(hooks...)
	c.User.Use(hooks...)
}

// DiscordAccountClient is a client for the DiscordAccount schema.
type DiscordAccountClient struct {
	config
}

// NewDiscordAccountClient returns a client for the DiscordAccount from the given config.
func NewDiscordAccountClient(c config) *DiscordAccountClient {
	return &DiscordAccountClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `discordaccount.Hooks(f(g(h())))`.
func (c *DiscordAccountClient) Use(hooks ...Hook) {
	c.hooks.DiscordAccount = append(c.hooks.DiscordAccount, hooks...)
}

// Create returns a builder for creating a DiscordAccount entity.
func (c *DiscordAccountClient) Create() *DiscordAccountCreate {
	mutation := newDiscordAccountMutation(c.config, OpCreate)
	return &DiscordAccountCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DiscordAccount entities.
func (c *DiscordAccountClient) CreateBulk(builders ...*DiscordAccountCreate) *DiscordAccountCreateBulk {
	return &DiscordAccountCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DiscordAccount.
func (c *DiscordAccountClient) Update() *DiscordAccountUpdate {
	mutation := newDiscordAccountMutation(c.config, OpUpdate)
	return &DiscordAccountUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DiscordAccountClient) UpdateOne(da *DiscordAccount) *DiscordAccountUpdateOne {
	mutation := newDiscordAccountMutation(c.config, OpUpdateOne, withDiscordAccount(da))
	return &DiscordAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DiscordAccountClient) UpdateOneID(id int) *DiscordAccountUpdateOne {
	mutation := newDiscordAccountMutation(c.config, OpUpdateOne, withDiscordAccountID(id))
	return &DiscordAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DiscordAccount.
func (c *DiscordAccountClient) Delete() *DiscordAccountDelete {
	mutation := newDiscordAccountMutation(c.config, OpDelete)
	return &DiscordAccountDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *DiscordAccountClient) DeleteOne(da *DiscordAccount) *DiscordAccountDeleteOne {
	return c.DeleteOneID(da.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *DiscordAccountClient) DeleteOneID(id int) *DiscordAccountDeleteOne {
	builder := c.Delete().Where(discordaccount.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DiscordAccountDeleteOne{builder}
}

// Query returns a query builder for DiscordAccount.
func (c *DiscordAccountClient) Query() *DiscordAccountQuery {
	return &DiscordAccountQuery{
		config: c.config,
	}
}

// Get returns a DiscordAccount entity by its id.
func (c *DiscordAccountClient) Get(ctx context.Context, id int) (*DiscordAccount, error) {
	return c.Query().Where(discordaccount.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *DiscordAccountClient) GetX(ctx context.Context, id int) *DiscordAccount {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryOwner queries the owner edge of a DiscordAccount.
func (c *DiscordAccountClient) QueryOwner(da *DiscordAccount) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := da.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(discordaccount.Table, discordaccount.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, discordaccount.OwnerTable, discordaccount.OwnerColumn),
		)
		fromV = sqlgraph.Neighbors(da.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryBot queries the bot edge of a DiscordAccount.
func (c *DiscordAccountClient) QueryBot(da *DiscordAccount) *DiscordBotQuery {
	query := &DiscordBotQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := da.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(discordaccount.Table, discordaccount.FieldID, id),
			sqlgraph.To(discordbot.Table, discordbot.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, discordaccount.BotTable, discordaccount.BotColumn),
		)
		fromV = sqlgraph.Neighbors(da.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *DiscordAccountClient) Hooks() []Hook {
	hooks := c.hooks.DiscordAccount
	return append(hooks[:len(hooks):len(hooks)], discordaccount.Hooks[:]...)
}

// DiscordBotClient is a client for the DiscordBot schema.
type DiscordBotClient struct {
	config
}

// NewDiscordBotClient returns a client for the DiscordBot from the given config.
func NewDiscordBotClient(c config) *DiscordBotClient {
	return &DiscordBotClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `discordbot.Hooks(f(g(h())))`.
func (c *DiscordBotClient) Use(hooks ...Hook) {
	c.hooks.DiscordBot = append(c.hooks.DiscordBot, hooks...)
}

// Create returns a builder for creating a DiscordBot entity.
func (c *DiscordBotClient) Create() *DiscordBotCreate {
	mutation := newDiscordBotMutation(c.config, OpCreate)
	return &DiscordBotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DiscordBot entities.
func (c *DiscordBotClient) CreateBulk(builders ...*DiscordBotCreate) *DiscordBotCreateBulk {
	return &DiscordBotCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DiscordBot.
func (c *DiscordBotClient) Update() *DiscordBotUpdate {
	mutation := newDiscordBotMutation(c.config, OpUpdate)
	return &DiscordBotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DiscordBotClient) UpdateOne(db *DiscordBot) *DiscordBotUpdateOne {
	mutation := newDiscordBotMutation(c.config, OpUpdateOne, withDiscordBot(db))
	return &DiscordBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DiscordBotClient) UpdateOneID(id int) *DiscordBotUpdateOne {
	mutation := newDiscordBotMutation(c.config, OpUpdateOne, withDiscordBotID(id))
	return &DiscordBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DiscordBot.
func (c *DiscordBotClient) Delete() *DiscordBotDelete {
	mutation := newDiscordBotMutation(c.config, OpDelete)
	return &DiscordBotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *DiscordBotClient) DeleteOne(db *DiscordBot) *DiscordBotDeleteOne {
	return c.DeleteOneID(db.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *DiscordBotClient) DeleteOneID(id int) *DiscordBotDeleteOne {
	builder := c.Delete().Where(discordbot.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DiscordBotDeleteOne{builder}
}

// Query returns a query builder for DiscordBot.
func (c *DiscordBotClient) Query() *DiscordBotQuery {
	return &DiscordBotQuery{
		config: c.config,
	}
}

// Get returns a DiscordBot entity by its id.
func (c *DiscordBotClient) Get(ctx context.Context, id int) (*DiscordBot, error) {
	return c.Query().Where(discordbot.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *DiscordBotClient) GetX(ctx context.Context, id int) *DiscordBot {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryAccount queries the account edge of a DiscordBot.
func (c *DiscordBotClient) QueryAccount(db *DiscordBot) *DiscordAccountQuery {
	query := &DiscordAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := db.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(discordbot.Table, discordbot.FieldID, id),
			sqlgraph.To(discordaccount.Table, discordaccount.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, discordbot.AccountTable, discordbot.AccountColumn),
		)
		fromV = sqlgraph.Neighbors(db.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryProject queries the project edge of a DiscordBot.
func (c *DiscordBotClient) QueryProject(db *DiscordBot) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := db.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(discordbot.Table, discordbot.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, discordbot.ProjectTable, discordbot.ProjectColumn),
		)
		fromV = sqlgraph.Neighbors(db.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepository queries the repository edge of a DiscordBot.
func (c *DiscordBotClient) QueryRepository(db *DiscordBot) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := db.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(discordbot.Table, discordbot.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, discordbot.RepositoryTable, discordbot.RepositoryColumn),
		)
		fromV = sqlgraph.Neighbors(db.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *DiscordBotClient) Hooks() []Hook {
	hooks := c.hooks.DiscordBot
	return append(hooks[:len(hooks):len(hooks)], discordbot.Hooks[:]...)
}

// GithubAccountClient is a client for the GithubAccount schema.
type GithubAccountClient struct {
	config
}

// NewGithubAccountClient returns a client for the GithubAccount from the given config.
func NewGithubAccountClient(c config) *GithubAccountClient {
	return &GithubAccountClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `githubaccount.Hooks(f(g(h())))`.
func (c *GithubAccountClient) Use(hooks ...Hook) {
	c.hooks.GithubAccount = append(c.hooks.GithubAccount, hooks...)
}

// Create returns a builder for creating a GithubAccount entity.
func (c *GithubAccountClient) Create() *GithubAccountCreate {
	mutation := newGithubAccountMutation(c.config, OpCreate)
	return &GithubAccountCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of GithubAccount entities.
func (c *GithubAccountClient) CreateBulk(builders ...*GithubAccountCreate) *GithubAccountCreateBulk {
	return &GithubAccountCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for GithubAccount.
func (c *GithubAccountClient) Update() *GithubAccountUpdate {
	mutation := newGithubAccountMutation(c.config, OpUpdate)
	return &GithubAccountUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *GithubAccountClient) UpdateOne(ga *GithubAccount) *GithubAccountUpdateOne {
	mutation := newGithubAccountMutation(c.config, OpUpdateOne, withGithubAccount(ga))
	return &GithubAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *GithubAccountClient) UpdateOneID(id int) *GithubAccountUpdateOne {
	mutation := newGithubAccountMutation(c.config, OpUpdateOne, withGithubAccountID(id))
	return &GithubAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for GithubAccount.
func (c *GithubAccountClient) Delete() *GithubAccountDelete {
	mutation := newGithubAccountMutation(c.config, OpDelete)
	return &GithubAccountDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *GithubAccountClient) DeleteOne(ga *GithubAccount) *GithubAccountDeleteOne {
	return c.DeleteOneID(ga.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *GithubAccountClient) DeleteOneID(id int) *GithubAccountDeleteOne {
	builder := c.Delete().Where(githubaccount.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &GithubAccountDeleteOne{builder}
}

// Query returns a query builder for GithubAccount.
func (c *GithubAccountClient) Query() *GithubAccountQuery {
	return &GithubAccountQuery{
		config: c.config,
	}
}

// Get returns a GithubAccount entity by its id.
func (c *GithubAccountClient) Get(ctx context.Context, id int) (*GithubAccount, error) {
	return c.Query().Where(githubaccount.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *GithubAccountClient) GetX(ctx context.Context, id int) *GithubAccount {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryOwner queries the owner edge of a GithubAccount.
func (c *GithubAccountClient) QueryOwner(ga *GithubAccount) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ga.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githubaccount.Table, githubaccount.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, githubaccount.OwnerTable, githubaccount.OwnerColumn),
		)
		fromV = sqlgraph.Neighbors(ga.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrganizationMemberships queries the organization_memberships edge of a GithubAccount.
func (c *GithubAccountClient) QueryOrganizationMemberships(ga *GithubAccount) *GithubOrganizationMemberQuery {
	query := &GithubOrganizationMemberQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ga.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githubaccount.Table, githubaccount.FieldID, id),
			sqlgraph.To(githuborganizationmember.Table, githuborganizationmember.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, githubaccount.OrganizationMembershipsTable, githubaccount.OrganizationMembershipsColumn),
		)
		fromV = sqlgraph.Neighbors(ga.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepositories queries the repositories edge of a GithubAccount.
func (c *GithubAccountClient) QueryRepositories(ga *GithubAccount) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ga.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githubaccount.Table, githubaccount.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, githubaccount.RepositoriesTable, githubaccount.RepositoriesColumn),
		)
		fromV = sqlgraph.Neighbors(ga.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *GithubAccountClient) Hooks() []Hook {
	hooks := c.hooks.GithubAccount
	return append(hooks[:len(hooks):len(hooks)], githubaccount.Hooks[:]...)
}

// GithubOrganizationClient is a client for the GithubOrganization schema.
type GithubOrganizationClient struct {
	config
}

// NewGithubOrganizationClient returns a client for the GithubOrganization from the given config.
func NewGithubOrganizationClient(c config) *GithubOrganizationClient {
	return &GithubOrganizationClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `githuborganization.Hooks(f(g(h())))`.
func (c *GithubOrganizationClient) Use(hooks ...Hook) {
	c.hooks.GithubOrganization = append(c.hooks.GithubOrganization, hooks...)
}

// Create returns a builder for creating a GithubOrganization entity.
func (c *GithubOrganizationClient) Create() *GithubOrganizationCreate {
	mutation := newGithubOrganizationMutation(c.config, OpCreate)
	return &GithubOrganizationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of GithubOrganization entities.
func (c *GithubOrganizationClient) CreateBulk(builders ...*GithubOrganizationCreate) *GithubOrganizationCreateBulk {
	return &GithubOrganizationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for GithubOrganization.
func (c *GithubOrganizationClient) Update() *GithubOrganizationUpdate {
	mutation := newGithubOrganizationMutation(c.config, OpUpdate)
	return &GithubOrganizationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *GithubOrganizationClient) UpdateOne(_go *GithubOrganization) *GithubOrganizationUpdateOne {
	mutation := newGithubOrganizationMutation(c.config, OpUpdateOne, withGithubOrganization(_go))
	return &GithubOrganizationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *GithubOrganizationClient) UpdateOneID(id int) *GithubOrganizationUpdateOne {
	mutation := newGithubOrganizationMutation(c.config, OpUpdateOne, withGithubOrganizationID(id))
	return &GithubOrganizationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for GithubOrganization.
func (c *GithubOrganizationClient) Delete() *GithubOrganizationDelete {
	mutation := newGithubOrganizationMutation(c.config, OpDelete)
	return &GithubOrganizationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *GithubOrganizationClient) DeleteOne(_go *GithubOrganization) *GithubOrganizationDeleteOne {
	return c.DeleteOneID(_go.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *GithubOrganizationClient) DeleteOneID(id int) *GithubOrganizationDeleteOne {
	builder := c.Delete().Where(githuborganization.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &GithubOrganizationDeleteOne{builder}
}

// Query returns a query builder for GithubOrganization.
func (c *GithubOrganizationClient) Query() *GithubOrganizationQuery {
	return &GithubOrganizationQuery{
		config: c.config,
	}
}

// Get returns a GithubOrganization entity by its id.
func (c *GithubOrganizationClient) Get(ctx context.Context, id int) (*GithubOrganization, error) {
	return c.Query().Where(githuborganization.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *GithubOrganizationClient) GetX(ctx context.Context, id int) *GithubOrganization {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryMembers queries the members edge of a GithubOrganization.
func (c *GithubOrganizationClient) QueryMembers(_go *GithubOrganization) *GithubOrganizationMemberQuery {
	query := &GithubOrganizationMemberQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := _go.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githuborganization.Table, githuborganization.FieldID, id),
			sqlgraph.To(githuborganizationmember.Table, githuborganizationmember.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, githuborganization.MembersTable, githuborganization.MembersColumn),
		)
		fromV = sqlgraph.Neighbors(_go.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepositories queries the repositories edge of a GithubOrganization.
func (c *GithubOrganizationClient) QueryRepositories(_go *GithubOrganization) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := _go.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githuborganization.Table, githuborganization.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, githuborganization.RepositoriesTable, githuborganization.RepositoriesColumn),
		)
		fromV = sqlgraph.Neighbors(_go.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *GithubOrganizationClient) Hooks() []Hook {
	hooks := c.hooks.GithubOrganization
	return append(hooks[:len(hooks):len(hooks)], githuborganization.Hooks[:]...)
}

// GithubOrganizationMemberClient is a client for the GithubOrganizationMember schema.
type GithubOrganizationMemberClient struct {
	config
}

// NewGithubOrganizationMemberClient returns a client for the GithubOrganizationMember from the given config.
func NewGithubOrganizationMemberClient(c config) *GithubOrganizationMemberClient {
	return &GithubOrganizationMemberClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `githuborganizationmember.Hooks(f(g(h())))`.
func (c *GithubOrganizationMemberClient) Use(hooks ...Hook) {
	c.hooks.GithubOrganizationMember = append(c.hooks.GithubOrganizationMember, hooks...)
}

// Create returns a builder for creating a GithubOrganizationMember entity.
func (c *GithubOrganizationMemberClient) Create() *GithubOrganizationMemberCreate {
	mutation := newGithubOrganizationMemberMutation(c.config, OpCreate)
	return &GithubOrganizationMemberCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of GithubOrganizationMember entities.
func (c *GithubOrganizationMemberClient) CreateBulk(builders ...*GithubOrganizationMemberCreate) *GithubOrganizationMemberCreateBulk {
	return &GithubOrganizationMemberCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for GithubOrganizationMember.
func (c *GithubOrganizationMemberClient) Update() *GithubOrganizationMemberUpdate {
	mutation := newGithubOrganizationMemberMutation(c.config, OpUpdate)
	return &GithubOrganizationMemberUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *GithubOrganizationMemberClient) UpdateOne(gom *GithubOrganizationMember) *GithubOrganizationMemberUpdateOne {
	mutation := newGithubOrganizationMemberMutation(c.config, OpUpdateOne, withGithubOrganizationMember(gom))
	return &GithubOrganizationMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *GithubOrganizationMemberClient) UpdateOneID(id int) *GithubOrganizationMemberUpdateOne {
	mutation := newGithubOrganizationMemberMutation(c.config, OpUpdateOne, withGithubOrganizationMemberID(id))
	return &GithubOrganizationMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for GithubOrganizationMember.
func (c *GithubOrganizationMemberClient) Delete() *GithubOrganizationMemberDelete {
	mutation := newGithubOrganizationMemberMutation(c.config, OpDelete)
	return &GithubOrganizationMemberDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *GithubOrganizationMemberClient) DeleteOne(gom *GithubOrganizationMember) *GithubOrganizationMemberDeleteOne {
	return c.DeleteOneID(gom.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *GithubOrganizationMemberClient) DeleteOneID(id int) *GithubOrganizationMemberDeleteOne {
	builder := c.Delete().Where(githuborganizationmember.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &GithubOrganizationMemberDeleteOne{builder}
}

// Query returns a query builder for GithubOrganizationMember.
func (c *GithubOrganizationMemberClient) Query() *GithubOrganizationMemberQuery {
	return &GithubOrganizationMemberQuery{
		config: c.config,
	}
}

// Get returns a GithubOrganizationMember entity by its id.
func (c *GithubOrganizationMemberClient) Get(ctx context.Context, id int) (*GithubOrganizationMember, error) {
	return c.Query().Where(githuborganizationmember.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *GithubOrganizationMemberClient) GetX(ctx context.Context, id int) *GithubOrganizationMember {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryOrganization queries the organization edge of a GithubOrganizationMember.
func (c *GithubOrganizationMemberClient) QueryOrganization(gom *GithubOrganizationMember) *GithubOrganizationQuery {
	query := &GithubOrganizationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := gom.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githuborganizationmember.Table, githuborganizationmember.FieldID, id),
			sqlgraph.To(githuborganization.Table, githuborganization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, githuborganizationmember.OrganizationTable, githuborganizationmember.OrganizationColumn),
		)
		fromV = sqlgraph.Neighbors(gom.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryAccount queries the account edge of a GithubOrganizationMember.
func (c *GithubOrganizationMemberClient) QueryAccount(gom *GithubOrganizationMember) *GithubAccountQuery {
	query := &GithubAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := gom.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(githuborganizationmember.Table, githuborganizationmember.FieldID, id),
			sqlgraph.To(githubaccount.Table, githubaccount.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, githuborganizationmember.AccountTable, githuborganizationmember.AccountColumn),
		)
		fromV = sqlgraph.Neighbors(gom.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *GithubOrganizationMemberClient) Hooks() []Hook {
	hooks := c.hooks.GithubOrganizationMember
	return append(hooks[:len(hooks):len(hooks)], githuborganizationmember.Hooks[:]...)
}

// ProjectClient is a client for the Project schema.
type ProjectClient struct {
	config
}

// NewProjectClient returns a client for the Project from the given config.
func NewProjectClient(c config) *ProjectClient {
	return &ProjectClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `project.Hooks(f(g(h())))`.
func (c *ProjectClient) Use(hooks ...Hook) {
	c.hooks.Project = append(c.hooks.Project, hooks...)
}

// Create returns a builder for creating a Project entity.
func (c *ProjectClient) Create() *ProjectCreate {
	mutation := newProjectMutation(c.config, OpCreate)
	return &ProjectCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Project entities.
func (c *ProjectClient) CreateBulk(builders ...*ProjectCreate) *ProjectCreateBulk {
	return &ProjectCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Project.
func (c *ProjectClient) Update() *ProjectUpdate {
	mutation := newProjectMutation(c.config, OpUpdate)
	return &ProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProjectClient) UpdateOne(pr *Project) *ProjectUpdateOne {
	mutation := newProjectMutation(c.config, OpUpdateOne, withProject(pr))
	return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProjectClient) UpdateOneID(id int) *ProjectUpdateOne {
	mutation := newProjectMutation(c.config, OpUpdateOne, withProjectID(id))
	return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Project.
func (c *ProjectClient) Delete() *ProjectDelete {
	mutation := newProjectMutation(c.config, OpDelete)
	return &ProjectDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectClient) DeleteOne(pr *Project) *ProjectDeleteOne {
	return c.DeleteOneID(pr.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ProjectClient) DeleteOneID(id int) *ProjectDeleteOne {
	builder := c.Delete().Where(project.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ProjectDeleteOne{builder}
}

// Query returns a query builder for Project.
func (c *ProjectClient) Query() *ProjectQuery {
	return &ProjectQuery{
		config: c.config,
	}
}

// Get returns a Project entity by its id.
func (c *ProjectClient) Get(ctx context.Context, id int) (*Project, error) {
	return c.Query().Where(project.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ProjectClient) GetX(ctx context.Context, id int) *Project {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryContributors queries the contributors edge of a Project.
func (c *ProjectClient) QueryContributors(pr *Project) *ProjectContributorQuery {
	query := &ProjectContributorQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(projectcontributor.Table, projectcontributor.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.ContributorsTable, project.ContributorsColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryParentProjects queries the parent_projects edge of a Project.
func (c *ProjectClient) QueryParentProjects(pr *Project) *ProjectAssociationQuery {
	query := &ProjectAssociationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(projectassociation.Table, projectassociation.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.ParentProjectsTable, project.ParentProjectsColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChildProjects queries the child_projects edge of a Project.
func (c *ProjectClient) QueryChildProjects(pr *Project) *ProjectAssociationQuery {
	query := &ProjectAssociationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(projectassociation.Table, projectassociation.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.ChildProjectsTable, project.ChildProjectsColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepositories queries the repositories edge of a Project.
func (c *ProjectClient) QueryRepositories(pr *Project) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.RepositoriesTable, project.RepositoriesColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDiscordBots queries the discord_bots edge of a Project.
func (c *ProjectClient) QueryDiscordBots(pr *Project) *DiscordBotQuery {
	query := &DiscordBotQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(discordbot.Table, discordbot.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.DiscordBotsTable, project.DiscordBotsColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySites queries the sites edge of a Project.
func (c *ProjectClient) QuerySites(pr *Project) *SiteQuery {
	query := &SiteQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(site.Table, site.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.SitesTable, project.SitesColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTechnologies queries the technologies edge of a Project.
func (c *ProjectClient) QueryTechnologies(pr *Project) *ProjectTechnologyQuery {
	query := &ProjectTechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(project.Table, project.FieldID, id),
			sqlgraph.To(projecttechnology.Table, projecttechnology.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, project.TechnologiesTable, project.TechnologiesColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *ProjectClient) Hooks() []Hook {
	hooks := c.hooks.Project
	return append(hooks[:len(hooks):len(hooks)], project.Hooks[:]...)
}

// ProjectAssociationClient is a client for the ProjectAssociation schema.
type ProjectAssociationClient struct {
	config
}

// NewProjectAssociationClient returns a client for the ProjectAssociation from the given config.
func NewProjectAssociationClient(c config) *ProjectAssociationClient {
	return &ProjectAssociationClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectassociation.Hooks(f(g(h())))`.
func (c *ProjectAssociationClient) Use(hooks ...Hook) {
	c.hooks.ProjectAssociation = append(c.hooks.ProjectAssociation, hooks...)
}

// Create returns a builder for creating a ProjectAssociation entity.
func (c *ProjectAssociationClient) Create() *ProjectAssociationCreate {
	mutation := newProjectAssociationMutation(c.config, OpCreate)
	return &ProjectAssociationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ProjectAssociation entities.
func (c *ProjectAssociationClient) CreateBulk(builders ...*ProjectAssociationCreate) *ProjectAssociationCreateBulk {
	return &ProjectAssociationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ProjectAssociation.
func (c *ProjectAssociationClient) Update() *ProjectAssociationUpdate {
	mutation := newProjectAssociationMutation(c.config, OpUpdate)
	return &ProjectAssociationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProjectAssociationClient) UpdateOne(pa *ProjectAssociation) *ProjectAssociationUpdateOne {
	mutation := newProjectAssociationMutation(c.config, OpUpdateOne, withProjectAssociation(pa))
	return &ProjectAssociationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProjectAssociationClient) UpdateOneID(id int) *ProjectAssociationUpdateOne {
	mutation := newProjectAssociationMutation(c.config, OpUpdateOne, withProjectAssociationID(id))
	return &ProjectAssociationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ProjectAssociation.
func (c *ProjectAssociationClient) Delete() *ProjectAssociationDelete {
	mutation := newProjectAssociationMutation(c.config, OpDelete)
	return &ProjectAssociationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectAssociationClient) DeleteOne(pa *ProjectAssociation) *ProjectAssociationDeleteOne {
	return c.DeleteOneID(pa.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ProjectAssociationClient) DeleteOneID(id int) *ProjectAssociationDeleteOne {
	builder := c.Delete().Where(projectassociation.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ProjectAssociationDeleteOne{builder}
}

// Query returns a query builder for ProjectAssociation.
func (c *ProjectAssociationClient) Query() *ProjectAssociationQuery {
	return &ProjectAssociationQuery{
		config: c.config,
	}
}

// Get returns a ProjectAssociation entity by its id.
func (c *ProjectAssociationClient) Get(ctx context.Context, id int) (*ProjectAssociation, error) {
	return c.Query().Where(projectassociation.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ProjectAssociationClient) GetX(ctx context.Context, id int) *ProjectAssociation {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryParent queries the parent edge of a ProjectAssociation.
func (c *ProjectAssociationClient) QueryParent(pa *ProjectAssociation) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projectassociation.Table, projectassociation.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projectassociation.ParentTable, projectassociation.ParentColumn),
		)
		fromV = sqlgraph.Neighbors(pa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChild queries the child edge of a ProjectAssociation.
func (c *ProjectAssociationClient) QueryChild(pa *ProjectAssociation) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projectassociation.Table, projectassociation.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projectassociation.ChildTable, projectassociation.ChildColumn),
		)
		fromV = sqlgraph.Neighbors(pa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *ProjectAssociationClient) Hooks() []Hook {
	hooks := c.hooks.ProjectAssociation
	return append(hooks[:len(hooks):len(hooks)], projectassociation.Hooks[:]...)
}

// ProjectContributorClient is a client for the ProjectContributor schema.
type ProjectContributorClient struct {
	config
}

// NewProjectContributorClient returns a client for the ProjectContributor from the given config.
func NewProjectContributorClient(c config) *ProjectContributorClient {
	return &ProjectContributorClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectcontributor.Hooks(f(g(h())))`.
func (c *ProjectContributorClient) Use(hooks ...Hook) {
	c.hooks.ProjectContributor = append(c.hooks.ProjectContributor, hooks...)
}

// Create returns a builder for creating a ProjectContributor entity.
func (c *ProjectContributorClient) Create() *ProjectContributorCreate {
	mutation := newProjectContributorMutation(c.config, OpCreate)
	return &ProjectContributorCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ProjectContributor entities.
func (c *ProjectContributorClient) CreateBulk(builders ...*ProjectContributorCreate) *ProjectContributorCreateBulk {
	return &ProjectContributorCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ProjectContributor.
func (c *ProjectContributorClient) Update() *ProjectContributorUpdate {
	mutation := newProjectContributorMutation(c.config, OpUpdate)
	return &ProjectContributorUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProjectContributorClient) UpdateOne(pc *ProjectContributor) *ProjectContributorUpdateOne {
	mutation := newProjectContributorMutation(c.config, OpUpdateOne, withProjectContributor(pc))
	return &ProjectContributorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProjectContributorClient) UpdateOneID(id int) *ProjectContributorUpdateOne {
	mutation := newProjectContributorMutation(c.config, OpUpdateOne, withProjectContributorID(id))
	return &ProjectContributorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ProjectContributor.
func (c *ProjectContributorClient) Delete() *ProjectContributorDelete {
	mutation := newProjectContributorMutation(c.config, OpDelete)
	return &ProjectContributorDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectContributorClient) DeleteOne(pc *ProjectContributor) *ProjectContributorDeleteOne {
	return c.DeleteOneID(pc.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ProjectContributorClient) DeleteOneID(id int) *ProjectContributorDeleteOne {
	builder := c.Delete().Where(projectcontributor.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ProjectContributorDeleteOne{builder}
}

// Query returns a query builder for ProjectContributor.
func (c *ProjectContributorClient) Query() *ProjectContributorQuery {
	return &ProjectContributorQuery{
		config: c.config,
	}
}

// Get returns a ProjectContributor entity by its id.
func (c *ProjectContributorClient) Get(ctx context.Context, id int) (*ProjectContributor, error) {
	return c.Query().Where(projectcontributor.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ProjectContributorClient) GetX(ctx context.Context, id int) *ProjectContributor {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryProject queries the project edge of a ProjectContributor.
func (c *ProjectContributorClient) QueryProject(pc *ProjectContributor) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pc.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projectcontributor.Table, projectcontributor.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projectcontributor.ProjectTable, projectcontributor.ProjectColumn),
		)
		fromV = sqlgraph.Neighbors(pc.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryUser queries the user edge of a ProjectContributor.
func (c *ProjectContributorClient) QueryUser(pc *ProjectContributor) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pc.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projectcontributor.Table, projectcontributor.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projectcontributor.UserTable, projectcontributor.UserColumn),
		)
		fromV = sqlgraph.Neighbors(pc.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *ProjectContributorClient) Hooks() []Hook {
	hooks := c.hooks.ProjectContributor
	return append(hooks[:len(hooks):len(hooks)], projectcontributor.Hooks[:]...)
}

// ProjectTechnologyClient is a client for the ProjectTechnology schema.
type ProjectTechnologyClient struct {
	config
}

// NewProjectTechnologyClient returns a client for the ProjectTechnology from the given config.
func NewProjectTechnologyClient(c config) *ProjectTechnologyClient {
	return &ProjectTechnologyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projecttechnology.Hooks(f(g(h())))`.
func (c *ProjectTechnologyClient) Use(hooks ...Hook) {
	c.hooks.ProjectTechnology = append(c.hooks.ProjectTechnology, hooks...)
}

// Create returns a builder for creating a ProjectTechnology entity.
func (c *ProjectTechnologyClient) Create() *ProjectTechnologyCreate {
	mutation := newProjectTechnologyMutation(c.config, OpCreate)
	return &ProjectTechnologyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ProjectTechnology entities.
func (c *ProjectTechnologyClient) CreateBulk(builders ...*ProjectTechnologyCreate) *ProjectTechnologyCreateBulk {
	return &ProjectTechnologyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ProjectTechnology.
func (c *ProjectTechnologyClient) Update() *ProjectTechnologyUpdate {
	mutation := newProjectTechnologyMutation(c.config, OpUpdate)
	return &ProjectTechnologyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProjectTechnologyClient) UpdateOne(pt *ProjectTechnology) *ProjectTechnologyUpdateOne {
	mutation := newProjectTechnologyMutation(c.config, OpUpdateOne, withProjectTechnology(pt))
	return &ProjectTechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProjectTechnologyClient) UpdateOneID(id int) *ProjectTechnologyUpdateOne {
	mutation := newProjectTechnologyMutation(c.config, OpUpdateOne, withProjectTechnologyID(id))
	return &ProjectTechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ProjectTechnology.
func (c *ProjectTechnologyClient) Delete() *ProjectTechnologyDelete {
	mutation := newProjectTechnologyMutation(c.config, OpDelete)
	return &ProjectTechnologyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectTechnologyClient) DeleteOne(pt *ProjectTechnology) *ProjectTechnologyDeleteOne {
	return c.DeleteOneID(pt.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *ProjectTechnologyClient) DeleteOneID(id int) *ProjectTechnologyDeleteOne {
	builder := c.Delete().Where(projecttechnology.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ProjectTechnologyDeleteOne{builder}
}

// Query returns a query builder for ProjectTechnology.
func (c *ProjectTechnologyClient) Query() *ProjectTechnologyQuery {
	return &ProjectTechnologyQuery{
		config: c.config,
	}
}

// Get returns a ProjectTechnology entity by its id.
func (c *ProjectTechnologyClient) Get(ctx context.Context, id int) (*ProjectTechnology, error) {
	return c.Query().Where(projecttechnology.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *ProjectTechnologyClient) GetX(ctx context.Context, id int) *ProjectTechnology {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryProject queries the project edge of a ProjectTechnology.
func (c *ProjectTechnologyClient) QueryProject(pt *ProjectTechnology) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projecttechnology.Table, projecttechnology.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projecttechnology.ProjectTable, projecttechnology.ProjectColumn),
		)
		fromV = sqlgraph.Neighbors(pt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTechnology queries the technology edge of a ProjectTechnology.
func (c *ProjectTechnologyClient) QueryTechnology(pt *ProjectTechnology) *TechnologyQuery {
	query := &TechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(projecttechnology.Table, projecttechnology.FieldID, id),
			sqlgraph.To(technology.Table, technology.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, projecttechnology.TechnologyTable, projecttechnology.TechnologyColumn),
		)
		fromV = sqlgraph.Neighbors(pt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *ProjectTechnologyClient) Hooks() []Hook {
	hooks := c.hooks.ProjectTechnology
	return append(hooks[:len(hooks):len(hooks)], projecttechnology.Hooks[:]...)
}

// RepositoryClient is a client for the Repository schema.
type RepositoryClient struct {
	config
}

// NewRepositoryClient returns a client for the Repository from the given config.
func NewRepositoryClient(c config) *RepositoryClient {
	return &RepositoryClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `repository.Hooks(f(g(h())))`.
func (c *RepositoryClient) Use(hooks ...Hook) {
	c.hooks.Repository = append(c.hooks.Repository, hooks...)
}

// Create returns a builder for creating a Repository entity.
func (c *RepositoryClient) Create() *RepositoryCreate {
	mutation := newRepositoryMutation(c.config, OpCreate)
	return &RepositoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Repository entities.
func (c *RepositoryClient) CreateBulk(builders ...*RepositoryCreate) *RepositoryCreateBulk {
	return &RepositoryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Repository.
func (c *RepositoryClient) Update() *RepositoryUpdate {
	mutation := newRepositoryMutation(c.config, OpUpdate)
	return &RepositoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *RepositoryClient) UpdateOne(r *Repository) *RepositoryUpdateOne {
	mutation := newRepositoryMutation(c.config, OpUpdateOne, withRepository(r))
	return &RepositoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *RepositoryClient) UpdateOneID(id int) *RepositoryUpdateOne {
	mutation := newRepositoryMutation(c.config, OpUpdateOne, withRepositoryID(id))
	return &RepositoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Repository.
func (c *RepositoryClient) Delete() *RepositoryDelete {
	mutation := newRepositoryMutation(c.config, OpDelete)
	return &RepositoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *RepositoryClient) DeleteOne(r *Repository) *RepositoryDeleteOne {
	return c.DeleteOneID(r.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *RepositoryClient) DeleteOneID(id int) *RepositoryDeleteOne {
	builder := c.Delete().Where(repository.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &RepositoryDeleteOne{builder}
}

// Query returns a query builder for Repository.
func (c *RepositoryClient) Query() *RepositoryQuery {
	return &RepositoryQuery{
		config: c.config,
	}
}

// Get returns a Repository entity by its id.
func (c *RepositoryClient) Get(ctx context.Context, id int) (*Repository, error) {
	return c.Query().Where(repository.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *RepositoryClient) GetX(ctx context.Context, id int) *Repository {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryProject queries the project edge of a Repository.
func (c *RepositoryClient) QueryProject(r *Repository) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, repository.ProjectTable, repository.ProjectColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryGithubAccount queries the github_account edge of a Repository.
func (c *RepositoryClient) QueryGithubAccount(r *Repository) *GithubAccountQuery {
	query := &GithubAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(githubaccount.Table, githubaccount.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, repository.GithubAccountTable, repository.GithubAccountColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryGithubOrganization queries the github_organization edge of a Repository.
func (c *RepositoryClient) QueryGithubOrganization(r *Repository) *GithubOrganizationQuery {
	query := &GithubOrganizationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(githuborganization.Table, githuborganization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, repository.GithubOrganizationTable, repository.GithubOrganizationColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDiscordBots queries the discord_bots edge of a Repository.
func (c *RepositoryClient) QueryDiscordBots(r *Repository) *DiscordBotQuery {
	query := &DiscordBotQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(discordbot.Table, discordbot.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repository.DiscordBotsTable, repository.DiscordBotsColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySites queries the sites edge of a Repository.
func (c *RepositoryClient) QuerySites(r *Repository) *SiteQuery {
	query := &SiteQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(site.Table, site.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repository.SitesTable, repository.SitesColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTechnologies queries the technologies edge of a Repository.
func (c *RepositoryClient) QueryTechnologies(r *Repository) *RepositoryTechnologyQuery {
	query := &RepositoryTechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repository.Table, repository.FieldID, id),
			sqlgraph.To(repositorytechnology.Table, repositorytechnology.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repository.TechnologiesTable, repository.TechnologiesColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *RepositoryClient) Hooks() []Hook {
	hooks := c.hooks.Repository
	return append(hooks[:len(hooks):len(hooks)], repository.Hooks[:]...)
}

// RepositoryTechnologyClient is a client for the RepositoryTechnology schema.
type RepositoryTechnologyClient struct {
	config
}

// NewRepositoryTechnologyClient returns a client for the RepositoryTechnology from the given config.
func NewRepositoryTechnologyClient(c config) *RepositoryTechnologyClient {
	return &RepositoryTechnologyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `repositorytechnology.Hooks(f(g(h())))`.
func (c *RepositoryTechnologyClient) Use(hooks ...Hook) {
	c.hooks.RepositoryTechnology = append(c.hooks.RepositoryTechnology, hooks...)
}

// Create returns a builder for creating a RepositoryTechnology entity.
func (c *RepositoryTechnologyClient) Create() *RepositoryTechnologyCreate {
	mutation := newRepositoryTechnologyMutation(c.config, OpCreate)
	return &RepositoryTechnologyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of RepositoryTechnology entities.
func (c *RepositoryTechnologyClient) CreateBulk(builders ...*RepositoryTechnologyCreate) *RepositoryTechnologyCreateBulk {
	return &RepositoryTechnologyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for RepositoryTechnology.
func (c *RepositoryTechnologyClient) Update() *RepositoryTechnologyUpdate {
	mutation := newRepositoryTechnologyMutation(c.config, OpUpdate)
	return &RepositoryTechnologyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *RepositoryTechnologyClient) UpdateOne(rt *RepositoryTechnology) *RepositoryTechnologyUpdateOne {
	mutation := newRepositoryTechnologyMutation(c.config, OpUpdateOne, withRepositoryTechnology(rt))
	return &RepositoryTechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *RepositoryTechnologyClient) UpdateOneID(id int) *RepositoryTechnologyUpdateOne {
	mutation := newRepositoryTechnologyMutation(c.config, OpUpdateOne, withRepositoryTechnologyID(id))
	return &RepositoryTechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for RepositoryTechnology.
func (c *RepositoryTechnologyClient) Delete() *RepositoryTechnologyDelete {
	mutation := newRepositoryTechnologyMutation(c.config, OpDelete)
	return &RepositoryTechnologyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *RepositoryTechnologyClient) DeleteOne(rt *RepositoryTechnology) *RepositoryTechnologyDeleteOne {
	return c.DeleteOneID(rt.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *RepositoryTechnologyClient) DeleteOneID(id int) *RepositoryTechnologyDeleteOne {
	builder := c.Delete().Where(repositorytechnology.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &RepositoryTechnologyDeleteOne{builder}
}

// Query returns a query builder for RepositoryTechnology.
func (c *RepositoryTechnologyClient) Query() *RepositoryTechnologyQuery {
	return &RepositoryTechnologyQuery{
		config: c.config,
	}
}

// Get returns a RepositoryTechnology entity by its id.
func (c *RepositoryTechnologyClient) Get(ctx context.Context, id int) (*RepositoryTechnology, error) {
	return c.Query().Where(repositorytechnology.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *RepositoryTechnologyClient) GetX(ctx context.Context, id int) *RepositoryTechnology {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryRepository queries the repository edge of a RepositoryTechnology.
func (c *RepositoryTechnologyClient) QueryRepository(rt *RepositoryTechnology) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := rt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repositorytechnology.Table, repositorytechnology.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, repositorytechnology.RepositoryTable, repositorytechnology.RepositoryColumn),
		)
		fromV = sqlgraph.Neighbors(rt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTechnology queries the technology edge of a RepositoryTechnology.
func (c *RepositoryTechnologyClient) QueryTechnology(rt *RepositoryTechnology) *TechnologyQuery {
	query := &TechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := rt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repositorytechnology.Table, repositorytechnology.FieldID, id),
			sqlgraph.To(technology.Table, technology.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, repositorytechnology.TechnologyTable, repositorytechnology.TechnologyColumn),
		)
		fromV = sqlgraph.Neighbors(rt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *RepositoryTechnologyClient) Hooks() []Hook {
	hooks := c.hooks.RepositoryTechnology
	return append(hooks[:len(hooks):len(hooks)], repositorytechnology.Hooks[:]...)
}

// SiteClient is a client for the Site schema.
type SiteClient struct {
	config
}

// NewSiteClient returns a client for the Site from the given config.
func NewSiteClient(c config) *SiteClient {
	return &SiteClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `site.Hooks(f(g(h())))`.
func (c *SiteClient) Use(hooks ...Hook) {
	c.hooks.Site = append(c.hooks.Site, hooks...)
}

// Create returns a builder for creating a Site entity.
func (c *SiteClient) Create() *SiteCreate {
	mutation := newSiteMutation(c.config, OpCreate)
	return &SiteCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Site entities.
func (c *SiteClient) CreateBulk(builders ...*SiteCreate) *SiteCreateBulk {
	return &SiteCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Site.
func (c *SiteClient) Update() *SiteUpdate {
	mutation := newSiteMutation(c.config, OpUpdate)
	return &SiteUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SiteClient) UpdateOne(s *Site) *SiteUpdateOne {
	mutation := newSiteMutation(c.config, OpUpdateOne, withSite(s))
	return &SiteUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SiteClient) UpdateOneID(id int) *SiteUpdateOne {
	mutation := newSiteMutation(c.config, OpUpdateOne, withSiteID(id))
	return &SiteUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Site.
func (c *SiteClient) Delete() *SiteDelete {
	mutation := newSiteMutation(c.config, OpDelete)
	return &SiteDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SiteClient) DeleteOne(s *Site) *SiteDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *SiteClient) DeleteOneID(id int) *SiteDeleteOne {
	builder := c.Delete().Where(site.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SiteDeleteOne{builder}
}

// Query returns a query builder for Site.
func (c *SiteClient) Query() *SiteQuery {
	return &SiteQuery{
		config: c.config,
	}
}

// Get returns a Site entity by its id.
func (c *SiteClient) Get(ctx context.Context, id int) (*Site, error) {
	return c.Query().Where(site.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *SiteClient) GetX(ctx context.Context, id int) *Site {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryProject queries the project edge of a Site.
func (c *SiteClient) QueryProject(s *Site) *ProjectQuery {
	query := &ProjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(site.Table, site.FieldID, id),
			sqlgraph.To(project.Table, project.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, site.ProjectTable, site.ProjectColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepository queries the repository edge of a Site.
func (c *SiteClient) QueryRepository(s *Site) *RepositoryQuery {
	query := &RepositoryQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(site.Table, site.FieldID, id),
			sqlgraph.To(repository.Table, repository.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, site.RepositoryTable, site.RepositoryColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *SiteClient) Hooks() []Hook {
	hooks := c.hooks.Site
	return append(hooks[:len(hooks):len(hooks)], site.Hooks[:]...)
}

// TechnologyClient is a client for the Technology schema.
type TechnologyClient struct {
	config
}

// NewTechnologyClient returns a client for the Technology from the given config.
func NewTechnologyClient(c config) *TechnologyClient {
	return &TechnologyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `technology.Hooks(f(g(h())))`.
func (c *TechnologyClient) Use(hooks ...Hook) {
	c.hooks.Technology = append(c.hooks.Technology, hooks...)
}

// Create returns a builder for creating a Technology entity.
func (c *TechnologyClient) Create() *TechnologyCreate {
	mutation := newTechnologyMutation(c.config, OpCreate)
	return &TechnologyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Technology entities.
func (c *TechnologyClient) CreateBulk(builders ...*TechnologyCreate) *TechnologyCreateBulk {
	return &TechnologyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Technology.
func (c *TechnologyClient) Update() *TechnologyUpdate {
	mutation := newTechnologyMutation(c.config, OpUpdate)
	return &TechnologyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TechnologyClient) UpdateOne(t *Technology) *TechnologyUpdateOne {
	mutation := newTechnologyMutation(c.config, OpUpdateOne, withTechnology(t))
	return &TechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TechnologyClient) UpdateOneID(id int) *TechnologyUpdateOne {
	mutation := newTechnologyMutation(c.config, OpUpdateOne, withTechnologyID(id))
	return &TechnologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Technology.
func (c *TechnologyClient) Delete() *TechnologyDelete {
	mutation := newTechnologyMutation(c.config, OpDelete)
	return &TechnologyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *TechnologyClient) DeleteOne(t *Technology) *TechnologyDeleteOne {
	return c.DeleteOneID(t.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *TechnologyClient) DeleteOneID(id int) *TechnologyDeleteOne {
	builder := c.Delete().Where(technology.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TechnologyDeleteOne{builder}
}

// Query returns a query builder for Technology.
func (c *TechnologyClient) Query() *TechnologyQuery {
	return &TechnologyQuery{
		config: c.config,
	}
}

// Get returns a Technology entity by its id.
func (c *TechnologyClient) Get(ctx context.Context, id int) (*Technology, error) {
	return c.Query().Where(technology.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *TechnologyClient) GetX(ctx context.Context, id int) *Technology {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryParentTechnologies queries the parent_technologies edge of a Technology.
func (c *TechnologyClient) QueryParentTechnologies(t *Technology) *TechnologyAssociationQuery {
	query := &TechnologyAssociationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technology.Table, technology.FieldID, id),
			sqlgraph.To(technologyassociation.Table, technologyassociation.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, technology.ParentTechnologiesTable, technology.ParentTechnologiesColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChildTechnologies queries the child_technologies edge of a Technology.
func (c *TechnologyClient) QueryChildTechnologies(t *Technology) *TechnologyAssociationQuery {
	query := &TechnologyAssociationQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technology.Table, technology.FieldID, id),
			sqlgraph.To(technologyassociation.Table, technologyassociation.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, technology.ChildTechnologiesTable, technology.ChildTechnologiesColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryProjects queries the projects edge of a Technology.
func (c *TechnologyClient) QueryProjects(t *Technology) *ProjectTechnologyQuery {
	query := &ProjectTechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technology.Table, technology.FieldID, id),
			sqlgraph.To(projecttechnology.Table, projecttechnology.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, technology.ProjectsTable, technology.ProjectsColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepositories queries the repositories edge of a Technology.
func (c *TechnologyClient) QueryRepositories(t *Technology) *RepositoryTechnologyQuery {
	query := &RepositoryTechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technology.Table, technology.FieldID, id),
			sqlgraph.To(repositorytechnology.Table, repositorytechnology.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, technology.RepositoriesTable, technology.RepositoriesColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *TechnologyClient) Hooks() []Hook {
	hooks := c.hooks.Technology
	return append(hooks[:len(hooks):len(hooks)], technology.Hooks[:]...)
}

// TechnologyAssociationClient is a client for the TechnologyAssociation schema.
type TechnologyAssociationClient struct {
	config
}

// NewTechnologyAssociationClient returns a client for the TechnologyAssociation from the given config.
func NewTechnologyAssociationClient(c config) *TechnologyAssociationClient {
	return &TechnologyAssociationClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `technologyassociation.Hooks(f(g(h())))`.
func (c *TechnologyAssociationClient) Use(hooks ...Hook) {
	c.hooks.TechnologyAssociation = append(c.hooks.TechnologyAssociation, hooks...)
}

// Create returns a builder for creating a TechnologyAssociation entity.
func (c *TechnologyAssociationClient) Create() *TechnologyAssociationCreate {
	mutation := newTechnologyAssociationMutation(c.config, OpCreate)
	return &TechnologyAssociationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of TechnologyAssociation entities.
func (c *TechnologyAssociationClient) CreateBulk(builders ...*TechnologyAssociationCreate) *TechnologyAssociationCreateBulk {
	return &TechnologyAssociationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for TechnologyAssociation.
func (c *TechnologyAssociationClient) Update() *TechnologyAssociationUpdate {
	mutation := newTechnologyAssociationMutation(c.config, OpUpdate)
	return &TechnologyAssociationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TechnologyAssociationClient) UpdateOne(ta *TechnologyAssociation) *TechnologyAssociationUpdateOne {
	mutation := newTechnologyAssociationMutation(c.config, OpUpdateOne, withTechnologyAssociation(ta))
	return &TechnologyAssociationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TechnologyAssociationClient) UpdateOneID(id int) *TechnologyAssociationUpdateOne {
	mutation := newTechnologyAssociationMutation(c.config, OpUpdateOne, withTechnologyAssociationID(id))
	return &TechnologyAssociationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for TechnologyAssociation.
func (c *TechnologyAssociationClient) Delete() *TechnologyAssociationDelete {
	mutation := newTechnologyAssociationMutation(c.config, OpDelete)
	return &TechnologyAssociationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *TechnologyAssociationClient) DeleteOne(ta *TechnologyAssociation) *TechnologyAssociationDeleteOne {
	return c.DeleteOneID(ta.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *TechnologyAssociationClient) DeleteOneID(id int) *TechnologyAssociationDeleteOne {
	builder := c.Delete().Where(technologyassociation.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TechnologyAssociationDeleteOne{builder}
}

// Query returns a query builder for TechnologyAssociation.
func (c *TechnologyAssociationClient) Query() *TechnologyAssociationQuery {
	return &TechnologyAssociationQuery{
		config: c.config,
	}
}

// Get returns a TechnologyAssociation entity by its id.
func (c *TechnologyAssociationClient) Get(ctx context.Context, id int) (*TechnologyAssociation, error) {
	return c.Query().Where(technologyassociation.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *TechnologyAssociationClient) GetX(ctx context.Context, id int) *TechnologyAssociation {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryParent queries the parent edge of a TechnologyAssociation.
func (c *TechnologyAssociationClient) QueryParent(ta *TechnologyAssociation) *TechnologyQuery {
	query := &TechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ta.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technologyassociation.Table, technologyassociation.FieldID, id),
			sqlgraph.To(technology.Table, technology.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, technologyassociation.ParentTable, technologyassociation.ParentColumn),
		)
		fromV = sqlgraph.Neighbors(ta.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChild queries the child edge of a TechnologyAssociation.
func (c *TechnologyAssociationClient) QueryChild(ta *TechnologyAssociation) *TechnologyQuery {
	query := &TechnologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ta.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(technologyassociation.Table, technologyassociation.FieldID, id),
			sqlgraph.To(technology.Table, technology.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, technologyassociation.ChildTable, technologyassociation.ChildColumn),
		)
		fromV = sqlgraph.Neighbors(ta.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *TechnologyAssociationClient) Hooks() []Hook {
	hooks := c.hooks.TechnologyAssociation
	return append(hooks[:len(hooks):len(hooks)], technologyassociation.Hooks[:]...)
}

// UserClient is a client for the User schema.
type UserClient struct {
	config
}

// NewUserClient returns a client for the User from the given config.
func NewUserClient(c config) *UserClient {
	return &UserClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `user.Hooks(f(g(h())))`.
func (c *UserClient) Use(hooks ...Hook) {
	c.hooks.User = append(c.hooks.User, hooks...)
}

// Create returns a builder for creating a User entity.
func (c *UserClient) Create() *UserCreate {
	mutation := newUserMutation(c.config, OpCreate)
	return &UserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of User entities.
func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk {
	return &UserCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for User.
func (c *UserClient) Update() *UserUpdate {
	mutation := newUserMutation(c.config, OpUpdate)
	return &UserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserClient) UpdateOne(u *User) *UserUpdateOne {
	mutation := newUserMutation(c.config, OpUpdateOne, withUser(u))
	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserClient) UpdateOneID(id int) *UserUpdateOne {
	mutation := newUserMutation(c.config, OpUpdateOne, withUserID(id))
	return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for User.
func (c *UserClient) Delete() *UserDelete {
	mutation := newUserMutation(c.config, OpDelete)
	return &UserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserClient) DeleteOne(u *User) *UserDeleteOne {
	return c.DeleteOneID(u.ID)
}

// DeleteOne returns a builder for deleting the given entity by its id.
func (c *UserClient) DeleteOneID(id int) *UserDeleteOne {
	builder := c.Delete().Where(user.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &UserDeleteOne{builder}
}

// Query returns a query builder for User.
func (c *UserClient) Query() *UserQuery {
	return &UserQuery{
		config: c.config,
	}
}

// Get returns a User entity by its id.
func (c *UserClient) Get(ctx context.Context, id int) (*User, error) {
	return c.Query().Where(user.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *UserClient) GetX(ctx context.Context, id int) *User {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryDiscordAccounts queries the discord_accounts edge of a User.
func (c *UserClient) QueryDiscordAccounts(u *User) *DiscordAccountQuery {
	query := &DiscordAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(discordaccount.Table, discordaccount.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.DiscordAccountsTable, user.DiscordAccountsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryGithubAccounts queries the github_accounts edge of a User.
func (c *UserClient) QueryGithubAccounts(u *User) *GithubAccountQuery {
	query := &GithubAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(githubaccount.Table, githubaccount.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.GithubAccountsTable, user.GithubAccountsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryProjectContributions queries the project_contributions edge of a User.
func (c *UserClient) QueryProjectContributions(u *User) *ProjectContributorQuery {
	query := &ProjectContributorQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(projectcontributor.Table, projectcontributor.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.ProjectContributionsTable, user.ProjectContributionsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *UserClient) Hooks() []Hook {
	hooks := c.hooks.User
	return append(hooks[:len(hooks):len(hooks)], user.Hooks[:]...)
}