client.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"log"

	"github.com/gitploy-io/gitploy/model/ent/migrate"

	"github.com/gitploy-io/gitploy/model/ent/chatuser"
	"github.com/gitploy-io/gitploy/model/ent/deployment"
	"github.com/gitploy-io/gitploy/model/ent/deploymentstatistics"
	"github.com/gitploy-io/gitploy/model/ent/deploymentstatus"
	"github.com/gitploy-io/gitploy/model/ent/event"
	"github.com/gitploy-io/gitploy/model/ent/lock"
	"github.com/gitploy-io/gitploy/model/ent/notificationrecord"
	"github.com/gitploy-io/gitploy/model/ent/perm"
	"github.com/gitploy-io/gitploy/model/ent/repo"
	"github.com/gitploy-io/gitploy/model/ent/review"
	"github.com/gitploy-io/gitploy/model/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
	// ChatUser is the client for interacting with the ChatUser builders.
	ChatUser *ChatUserClient
	// Deployment is the client for interacting with the Deployment builders.
	Deployment *DeploymentClient
	// DeploymentStatistics is the client for interacting with the DeploymentStatistics builders.
	DeploymentStatistics *DeploymentStatisticsClient
	// DeploymentStatus is the client for interacting with the DeploymentStatus builders.
	DeploymentStatus *DeploymentStatusClient
	// Event is the client for interacting with the Event builders.
	Event *EventClient
	// Lock is the client for interacting with the Lock builders.
	Lock *LockClient
	// NotificationRecord is the client for interacting with the NotificationRecord builders.
	NotificationRecord *NotificationRecordClient
	// Perm is the client for interacting with the Perm builders.
	Perm *PermClient
	// Repo is the client for interacting with the Repo builders.
	Repo *RepoClient
	// Review is the client for interacting with the Review builders.
	Review *ReviewClient
	// User is the client for interacting with the User builders.
	User *UserClient
}

// 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.ChatUser = NewChatUserClient(c.config)
	c.Deployment = NewDeploymentClient(c.config)
	c.DeploymentStatistics = NewDeploymentStatisticsClient(c.config)
	c.DeploymentStatus = NewDeploymentStatusClient(c.config)
	c.Event = NewEventClient(c.config)
	c.Lock = NewLockClient(c.config)
	c.NotificationRecord = NewNotificationRecordClient(c.config)
	c.Perm = NewPermClient(c.config)
	c.Repo = NewRepoClient(c.config)
	c.Review = NewReviewClient(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, fmt.Errorf("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,
		ChatUser:             NewChatUserClient(cfg),
		Deployment:           NewDeploymentClient(cfg),
		DeploymentStatistics: NewDeploymentStatisticsClient(cfg),
		DeploymentStatus:     NewDeploymentStatusClient(cfg),
		Event:                NewEventClient(cfg),
		Lock:                 NewLockClient(cfg),
		NotificationRecord:   NewNotificationRecordClient(cfg),
		Perm:                 NewPermClient(cfg),
		Repo:                 NewRepoClient(cfg),
		Review:               NewReviewClient(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, fmt.Errorf("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,
		ChatUser:             NewChatUserClient(cfg),
		Deployment:           NewDeploymentClient(cfg),
		DeploymentStatistics: NewDeploymentStatisticsClient(cfg),
		DeploymentStatus:     NewDeploymentStatusClient(cfg),
		Event:                NewEventClient(cfg),
		Lock:                 NewLockClient(cfg),
		NotificationRecord:   NewNotificationRecordClient(cfg),
		Perm:                 NewPermClient(cfg),
		Repo:                 NewRepoClient(cfg),
		Review:               NewReviewClient(cfg),
		User:                 NewUserClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		ChatUser.
//		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.ChatUser.Use(hooks...)
	c.Deployment.Use(hooks...)
	c.DeploymentStatistics.Use(hooks...)
	c.DeploymentStatus.Use(hooks...)
	c.Event.Use(hooks...)
	c.Lock.Use(hooks...)
	c.NotificationRecord.Use(hooks...)
	c.Perm.Use(hooks...)
	c.Repo.Use(hooks...)
	c.Review.Use(hooks...)
	c.User.Use(hooks...)
}

// ChatUserClient is a client for the ChatUser schema.
type ChatUserClient struct {
	config
}

// NewChatUserClient returns a client for the ChatUser from the given config.
func NewChatUserClient(c config) *ChatUserClient {
	return &ChatUserClient{config: c}
}

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

// Create returns a create builder for ChatUser.
func (c *ChatUserClient) Create() *ChatUserCreate {
	mutation := newChatUserMutation(c.config, OpCreate)
	return &ChatUserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ChatUser entities.
func (c *ChatUserClient) CreateBulk(builders ...*ChatUserCreate) *ChatUserCreateBulk {
	return &ChatUserCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ChatUser.
func (c *ChatUserClient) Update() *ChatUserUpdate {
	mutation := newChatUserMutation(c.config, OpUpdate)
	return &ChatUserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ChatUserClient) UpdateOne(cu *ChatUser) *ChatUserUpdateOne {
	mutation := newChatUserMutation(c.config, OpUpdateOne, withChatUser(cu))
	return &ChatUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ChatUserClient) UpdateOneID(id string) *ChatUserUpdateOne {
	mutation := newChatUserMutation(c.config, OpUpdateOne, withChatUserID(id))
	return &ChatUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ChatUser.
func (c *ChatUserClient) Delete() *ChatUserDelete {
	mutation := newChatUserMutation(c.config, OpDelete)
	return &ChatUserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ChatUserClient) DeleteOne(cu *ChatUser) *ChatUserDeleteOne {
	return c.DeleteOneID(cu.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ChatUserClient) DeleteOneID(id string) *ChatUserDeleteOne {
	builder := c.Delete().Where(chatuser.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ChatUserDeleteOne{builder}
}

// Query returns a query builder for ChatUser.
func (c *ChatUserClient) Query() *ChatUserQuery {
	return &ChatUserQuery{
		config: c.config,
	}
}

// Get returns a ChatUser entity by its id.
func (c *ChatUserClient) Get(ctx context.Context, id string) (*ChatUser, error) {
	return c.Query().Where(chatuser.ID(id)).Only(ctx)
}

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

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

// Hooks returns the client hooks.
func (c *ChatUserClient) Hooks() []Hook {
	return c.hooks.ChatUser
}

// DeploymentClient is a client for the Deployment schema.
type DeploymentClient struct {
	config
}

// NewDeploymentClient returns a client for the Deployment from the given config.
func NewDeploymentClient(c config) *DeploymentClient {
	return &DeploymentClient{config: c}
}

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

// Create returns a create builder for Deployment.
func (c *DeploymentClient) Create() *DeploymentCreate {
	mutation := newDeploymentMutation(c.config, OpCreate)
	return &DeploymentCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Deployment entities.
func (c *DeploymentClient) CreateBulk(builders ...*DeploymentCreate) *DeploymentCreateBulk {
	return &DeploymentCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Deployment.
func (c *DeploymentClient) Update() *DeploymentUpdate {
	mutation := newDeploymentMutation(c.config, OpUpdate)
	return &DeploymentUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeploymentClient) UpdateOne(d *Deployment) *DeploymentUpdateOne {
	mutation := newDeploymentMutation(c.config, OpUpdateOne, withDeployment(d))
	return &DeploymentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeploymentClient) UpdateOneID(id int) *DeploymentUpdateOne {
	mutation := newDeploymentMutation(c.config, OpUpdateOne, withDeploymentID(id))
	return &DeploymentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Deployment.
func (c *DeploymentClient) Delete() *DeploymentDelete {
	mutation := newDeploymentMutation(c.config, OpDelete)
	return &DeploymentDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeploymentClient) DeleteOne(d *Deployment) *DeploymentDeleteOne {
	return c.DeleteOneID(d.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeploymentClient) DeleteOneID(id int) *DeploymentDeleteOne {
	builder := c.Delete().Where(deployment.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeploymentDeleteOne{builder}
}

// Query returns a query builder for Deployment.
func (c *DeploymentClient) Query() *DeploymentQuery {
	return &DeploymentQuery{
		config: c.config,
	}
}

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

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

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

// QueryRepo queries the repo edge of a Deployment.
func (c *DeploymentClient) QueryRepo(d *Deployment) *RepoQuery {
	query := &RepoQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deployment.Table, deployment.FieldID, id),
			sqlgraph.To(repo.Table, repo.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, deployment.RepoTable, deployment.RepoColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryReviews queries the reviews edge of a Deployment.
func (c *DeploymentClient) QueryReviews(d *Deployment) *ReviewQuery {
	query := &ReviewQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deployment.Table, deployment.FieldID, id),
			sqlgraph.To(review.Table, review.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, deployment.ReviewsTable, deployment.ReviewsColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDeploymentStatuses queries the deployment_statuses edge of a Deployment.
func (c *DeploymentClient) QueryDeploymentStatuses(d *Deployment) *DeploymentStatusQuery {
	query := &DeploymentStatusQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deployment.Table, deployment.FieldID, id),
			sqlgraph.To(deploymentstatus.Table, deploymentstatus.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, deployment.DeploymentStatusesTable, deployment.DeploymentStatusesColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEvent queries the event edge of a Deployment.
func (c *DeploymentClient) QueryEvent(d *Deployment) *EventQuery {
	query := &EventQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deployment.Table, deployment.FieldID, id),
			sqlgraph.To(event.Table, event.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, deployment.EventTable, deployment.EventColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *DeploymentClient) Hooks() []Hook {
	return c.hooks.Deployment
}

// DeploymentStatisticsClient is a client for the DeploymentStatistics schema.
type DeploymentStatisticsClient struct {
	config
}

// NewDeploymentStatisticsClient returns a client for the DeploymentStatistics from the given config.
func NewDeploymentStatisticsClient(c config) *DeploymentStatisticsClient {
	return &DeploymentStatisticsClient{config: c}
}

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

// Create returns a create builder for DeploymentStatistics.
func (c *DeploymentStatisticsClient) Create() *DeploymentStatisticsCreate {
	mutation := newDeploymentStatisticsMutation(c.config, OpCreate)
	return &DeploymentStatisticsCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DeploymentStatistics entities.
func (c *DeploymentStatisticsClient) CreateBulk(builders ...*DeploymentStatisticsCreate) *DeploymentStatisticsCreateBulk {
	return &DeploymentStatisticsCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DeploymentStatistics.
func (c *DeploymentStatisticsClient) Update() *DeploymentStatisticsUpdate {
	mutation := newDeploymentStatisticsMutation(c.config, OpUpdate)
	return &DeploymentStatisticsUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeploymentStatisticsClient) UpdateOne(ds *DeploymentStatistics) *DeploymentStatisticsUpdateOne {
	mutation := newDeploymentStatisticsMutation(c.config, OpUpdateOne, withDeploymentStatistics(ds))
	return &DeploymentStatisticsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeploymentStatisticsClient) UpdateOneID(id int) *DeploymentStatisticsUpdateOne {
	mutation := newDeploymentStatisticsMutation(c.config, OpUpdateOne, withDeploymentStatisticsID(id))
	return &DeploymentStatisticsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DeploymentStatistics.
func (c *DeploymentStatisticsClient) Delete() *DeploymentStatisticsDelete {
	mutation := newDeploymentStatisticsMutation(c.config, OpDelete)
	return &DeploymentStatisticsDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeploymentStatisticsClient) DeleteOne(ds *DeploymentStatistics) *DeploymentStatisticsDeleteOne {
	return c.DeleteOneID(ds.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeploymentStatisticsClient) DeleteOneID(id int) *DeploymentStatisticsDeleteOne {
	builder := c.Delete().Where(deploymentstatistics.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeploymentStatisticsDeleteOne{builder}
}

// Query returns a query builder for DeploymentStatistics.
func (c *DeploymentStatisticsClient) Query() *DeploymentStatisticsQuery {
	return &DeploymentStatisticsQuery{
		config: c.config,
	}
}

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

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

// QueryRepo queries the repo edge of a DeploymentStatistics.
func (c *DeploymentStatisticsClient) QueryRepo(ds *DeploymentStatistics) *RepoQuery {
	query := &RepoQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ds.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deploymentstatistics.Table, deploymentstatistics.FieldID, id),
			sqlgraph.To(repo.Table, repo.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, deploymentstatistics.RepoTable, deploymentstatistics.RepoColumn),
		)
		fromV = sqlgraph.Neighbors(ds.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *DeploymentStatisticsClient) Hooks() []Hook {
	return c.hooks.DeploymentStatistics
}

// DeploymentStatusClient is a client for the DeploymentStatus schema.
type DeploymentStatusClient struct {
	config
}

// NewDeploymentStatusClient returns a client for the DeploymentStatus from the given config.
func NewDeploymentStatusClient(c config) *DeploymentStatusClient {
	return &DeploymentStatusClient{config: c}
}

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

// Create returns a create builder for DeploymentStatus.
func (c *DeploymentStatusClient) Create() *DeploymentStatusCreate {
	mutation := newDeploymentStatusMutation(c.config, OpCreate)
	return &DeploymentStatusCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DeploymentStatus entities.
func (c *DeploymentStatusClient) CreateBulk(builders ...*DeploymentStatusCreate) *DeploymentStatusCreateBulk {
	return &DeploymentStatusCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DeploymentStatus.
func (c *DeploymentStatusClient) Update() *DeploymentStatusUpdate {
	mutation := newDeploymentStatusMutation(c.config, OpUpdate)
	return &DeploymentStatusUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeploymentStatusClient) UpdateOne(ds *DeploymentStatus) *DeploymentStatusUpdateOne {
	mutation := newDeploymentStatusMutation(c.config, OpUpdateOne, withDeploymentStatus(ds))
	return &DeploymentStatusUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeploymentStatusClient) UpdateOneID(id int) *DeploymentStatusUpdateOne {
	mutation := newDeploymentStatusMutation(c.config, OpUpdateOne, withDeploymentStatusID(id))
	return &DeploymentStatusUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DeploymentStatus.
func (c *DeploymentStatusClient) Delete() *DeploymentStatusDelete {
	mutation := newDeploymentStatusMutation(c.config, OpDelete)
	return &DeploymentStatusDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeploymentStatusClient) DeleteOne(ds *DeploymentStatus) *DeploymentStatusDeleteOne {
	return c.DeleteOneID(ds.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeploymentStatusClient) DeleteOneID(id int) *DeploymentStatusDeleteOne {
	builder := c.Delete().Where(deploymentstatus.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeploymentStatusDeleteOne{builder}
}

// Query returns a query builder for DeploymentStatus.
func (c *DeploymentStatusClient) Query() *DeploymentStatusQuery {
	return &DeploymentStatusQuery{
		config: c.config,
	}
}

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

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

// QueryDeployment queries the deployment edge of a DeploymentStatus.
func (c *DeploymentStatusClient) QueryDeployment(ds *DeploymentStatus) *DeploymentQuery {
	query := &DeploymentQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ds.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deploymentstatus.Table, deploymentstatus.FieldID, id),
			sqlgraph.To(deployment.Table, deployment.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, deploymentstatus.DeploymentTable, deploymentstatus.DeploymentColumn),
		)
		fromV = sqlgraph.Neighbors(ds.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *DeploymentStatusClient) Hooks() []Hook {
	return c.hooks.DeploymentStatus
}

// EventClient is a client for the Event schema.
type EventClient struct {
	config
}

// NewEventClient returns a client for the Event from the given config.
func NewEventClient(c config) *EventClient {
	return &EventClient{config: c}
}

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

// Create returns a create builder for Event.
func (c *EventClient) Create() *EventCreate {
	mutation := newEventMutation(c.config, OpCreate)
	return &EventCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Event entities.
func (c *EventClient) CreateBulk(builders ...*EventCreate) *EventCreateBulk {
	return &EventCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Event.
func (c *EventClient) Update() *EventUpdate {
	mutation := newEventMutation(c.config, OpUpdate)
	return &EventUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *EventClient) UpdateOne(e *Event) *EventUpdateOne {
	mutation := newEventMutation(c.config, OpUpdateOne, withEvent(e))
	return &EventUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *EventClient) UpdateOneID(id int) *EventUpdateOne {
	mutation := newEventMutation(c.config, OpUpdateOne, withEventID(id))
	return &EventUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Event.
func (c *EventClient) Delete() *EventDelete {
	mutation := newEventMutation(c.config, OpDelete)
	return &EventDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *EventClient) DeleteOne(e *Event) *EventDeleteOne {
	return c.DeleteOneID(e.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *EventClient) DeleteOneID(id int) *EventDeleteOne {
	builder := c.Delete().Where(event.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &EventDeleteOne{builder}
}

// Query returns a query builder for Event.
func (c *EventClient) Query() *EventQuery {
	return &EventQuery{
		config: c.config,
	}
}

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

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

// QueryDeployment queries the deployment edge of a Event.
func (c *EventClient) QueryDeployment(e *Event) *DeploymentQuery {
	query := &DeploymentQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(event.Table, event.FieldID, id),
			sqlgraph.To(deployment.Table, deployment.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, event.DeploymentTable, event.DeploymentColumn),
		)
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryReview queries the review edge of a Event.
func (c *EventClient) QueryReview(e *Event) *ReviewQuery {
	query := &ReviewQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(event.Table, event.FieldID, id),
			sqlgraph.To(review.Table, review.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, event.ReviewTable, event.ReviewColumn),
		)
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryNotificationRecord queries the notification_record edge of a Event.
func (c *EventClient) QueryNotificationRecord(e *Event) *NotificationRecordQuery {
	query := &NotificationRecordQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(event.Table, event.FieldID, id),
			sqlgraph.To(notificationrecord.Table, notificationrecord.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, event.NotificationRecordTable, event.NotificationRecordColumn),
		)
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *EventClient) Hooks() []Hook {
	return c.hooks.Event
}

// LockClient is a client for the Lock schema.
type LockClient struct {
	config
}

// NewLockClient returns a client for the Lock from the given config.
func NewLockClient(c config) *LockClient {
	return &LockClient{config: c}
}

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

// Create returns a create builder for Lock.
func (c *LockClient) Create() *LockCreate {
	mutation := newLockMutation(c.config, OpCreate)
	return &LockCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Lock entities.
func (c *LockClient) CreateBulk(builders ...*LockCreate) *LockCreateBulk {
	return &LockCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Lock.
func (c *LockClient) Update() *LockUpdate {
	mutation := newLockMutation(c.config, OpUpdate)
	return &LockUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *LockClient) UpdateOne(l *Lock) *LockUpdateOne {
	mutation := newLockMutation(c.config, OpUpdateOne, withLock(l))
	return &LockUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *LockClient) UpdateOneID(id int) *LockUpdateOne {
	mutation := newLockMutation(c.config, OpUpdateOne, withLockID(id))
	return &LockUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Lock.
func (c *LockClient) Delete() *LockDelete {
	mutation := newLockMutation(c.config, OpDelete)
	return &LockDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *LockClient) DeleteOne(l *Lock) *LockDeleteOne {
	return c.DeleteOneID(l.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *LockClient) DeleteOneID(id int) *LockDeleteOne {
	builder := c.Delete().Where(lock.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &LockDeleteOne{builder}
}

// Query returns a query builder for Lock.
func (c *LockClient) Query() *LockQuery {
	return &LockQuery{
		config: c.config,
	}
}

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

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

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

// QueryRepo queries the repo edge of a Lock.
func (c *LockClient) QueryRepo(l *Lock) *RepoQuery {
	query := &RepoQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := l.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(lock.Table, lock.FieldID, id),
			sqlgraph.To(repo.Table, repo.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, lock.RepoTable, lock.RepoColumn),
		)
		fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *LockClient) Hooks() []Hook {
	return c.hooks.Lock
}

// NotificationRecordClient is a client for the NotificationRecord schema.
type NotificationRecordClient struct {
	config
}

// NewNotificationRecordClient returns a client for the NotificationRecord from the given config.
func NewNotificationRecordClient(c config) *NotificationRecordClient {
	return &NotificationRecordClient{config: c}
}

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

// Create returns a create builder for NotificationRecord.
func (c *NotificationRecordClient) Create() *NotificationRecordCreate {
	mutation := newNotificationRecordMutation(c.config, OpCreate)
	return &NotificationRecordCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of NotificationRecord entities.
func (c *NotificationRecordClient) CreateBulk(builders ...*NotificationRecordCreate) *NotificationRecordCreateBulk {
	return &NotificationRecordCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for NotificationRecord.
func (c *NotificationRecordClient) Update() *NotificationRecordUpdate {
	mutation := newNotificationRecordMutation(c.config, OpUpdate)
	return &NotificationRecordUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *NotificationRecordClient) UpdateOne(nr *NotificationRecord) *NotificationRecordUpdateOne {
	mutation := newNotificationRecordMutation(c.config, OpUpdateOne, withNotificationRecord(nr))
	return &NotificationRecordUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *NotificationRecordClient) UpdateOneID(id int) *NotificationRecordUpdateOne {
	mutation := newNotificationRecordMutation(c.config, OpUpdateOne, withNotificationRecordID(id))
	return &NotificationRecordUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for NotificationRecord.
func (c *NotificationRecordClient) Delete() *NotificationRecordDelete {
	mutation := newNotificationRecordMutation(c.config, OpDelete)
	return &NotificationRecordDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *NotificationRecordClient) DeleteOne(nr *NotificationRecord) *NotificationRecordDeleteOne {
	return c.DeleteOneID(nr.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *NotificationRecordClient) DeleteOneID(id int) *NotificationRecordDeleteOne {
	builder := c.Delete().Where(notificationrecord.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &NotificationRecordDeleteOne{builder}
}

// Query returns a query builder for NotificationRecord.
func (c *NotificationRecordClient) Query() *NotificationRecordQuery {
	return &NotificationRecordQuery{
		config: c.config,
	}
}

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

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

// QueryEvent queries the event edge of a NotificationRecord.
func (c *NotificationRecordClient) QueryEvent(nr *NotificationRecord) *EventQuery {
	query := &EventQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := nr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(notificationrecord.Table, notificationrecord.FieldID, id),
			sqlgraph.To(event.Table, event.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, notificationrecord.EventTable, notificationrecord.EventColumn),
		)
		fromV = sqlgraph.Neighbors(nr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *NotificationRecordClient) Hooks() []Hook {
	return c.hooks.NotificationRecord
}

// PermClient is a client for the Perm schema.
type PermClient struct {
	config
}

// NewPermClient returns a client for the Perm from the given config.
func NewPermClient(c config) *PermClient {
	return &PermClient{config: c}
}

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

// Create returns a create builder for Perm.
func (c *PermClient) Create() *PermCreate {
	mutation := newPermMutation(c.config, OpCreate)
	return &PermCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Perm entities.
func (c *PermClient) CreateBulk(builders ...*PermCreate) *PermCreateBulk {
	return &PermCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Perm.
func (c *PermClient) Update() *PermUpdate {
	mutation := newPermMutation(c.config, OpUpdate)
	return &PermUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PermClient) UpdateOne(pe *Perm) *PermUpdateOne {
	mutation := newPermMutation(c.config, OpUpdateOne, withPerm(pe))
	return &PermUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PermClient) UpdateOneID(id int) *PermUpdateOne {
	mutation := newPermMutation(c.config, OpUpdateOne, withPermID(id))
	return &PermUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Perm.
func (c *PermClient) Delete() *PermDelete {
	mutation := newPermMutation(c.config, OpDelete)
	return &PermDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *PermClient) DeleteOne(pe *Perm) *PermDeleteOne {
	return c.DeleteOneID(pe.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *PermClient) DeleteOneID(id int) *PermDeleteOne {
	builder := c.Delete().Where(perm.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &PermDeleteOne{builder}
}

// Query returns a query builder for Perm.
func (c *PermClient) Query() *PermQuery {
	return &PermQuery{
		config: c.config,
	}
}

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

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

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

// QueryRepo queries the repo edge of a Perm.
func (c *PermClient) QueryRepo(pe *Perm) *RepoQuery {
	query := &RepoQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pe.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(perm.Table, perm.FieldID, id),
			sqlgraph.To(repo.Table, repo.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, perm.RepoTable, perm.RepoColumn),
		)
		fromV = sqlgraph.Neighbors(pe.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *PermClient) Hooks() []Hook {
	return c.hooks.Perm
}

// RepoClient is a client for the Repo schema.
type RepoClient struct {
	config
}

// NewRepoClient returns a client for the Repo from the given config.
func NewRepoClient(c config) *RepoClient {
	return &RepoClient{config: c}
}

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

// Create returns a create builder for Repo.
func (c *RepoClient) Create() *RepoCreate {
	mutation := newRepoMutation(c.config, OpCreate)
	return &RepoCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Repo entities.
func (c *RepoClient) CreateBulk(builders ...*RepoCreate) *RepoCreateBulk {
	return &RepoCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Repo.
func (c *RepoClient) Update() *RepoUpdate {
	mutation := newRepoMutation(c.config, OpUpdate)
	return &RepoUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *RepoClient) UpdateOne(r *Repo) *RepoUpdateOne {
	mutation := newRepoMutation(c.config, OpUpdateOne, withRepo(r))
	return &RepoUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *RepoClient) UpdateOneID(id int64) *RepoUpdateOne {
	mutation := newRepoMutation(c.config, OpUpdateOne, withRepoID(id))
	return &RepoUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Repo.
func (c *RepoClient) Delete() *RepoDelete {
	mutation := newRepoMutation(c.config, OpDelete)
	return &RepoDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *RepoClient) DeleteOne(r *Repo) *RepoDeleteOne {
	return c.DeleteOneID(r.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *RepoClient) DeleteOneID(id int64) *RepoDeleteOne {
	builder := c.Delete().Where(repo.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &RepoDeleteOne{builder}
}

// Query returns a query builder for Repo.
func (c *RepoClient) Query() *RepoQuery {
	return &RepoQuery{
		config: c.config,
	}
}

// Get returns a Repo entity by its id.
func (c *RepoClient) Get(ctx context.Context, id int64) (*Repo, error) {
	return c.Query().Where(repo.ID(id)).Only(ctx)
}

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

// QueryPerms queries the perms edge of a Repo.
func (c *RepoClient) QueryPerms(r *Repo) *PermQuery {
	query := &PermQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repo.Table, repo.FieldID, id),
			sqlgraph.To(perm.Table, perm.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repo.PermsTable, repo.PermsColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDeployments queries the deployments edge of a Repo.
func (c *RepoClient) QueryDeployments(r *Repo) *DeploymentQuery {
	query := &DeploymentQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repo.Table, repo.FieldID, id),
			sqlgraph.To(deployment.Table, deployment.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repo.DeploymentsTable, repo.DeploymentsColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLocks queries the locks edge of a Repo.
func (c *RepoClient) QueryLocks(r *Repo) *LockQuery {
	query := &LockQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repo.Table, repo.FieldID, id),
			sqlgraph.To(lock.Table, lock.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repo.LocksTable, repo.LocksColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDeploymentStatistics queries the deployment_statistics edge of a Repo.
func (c *RepoClient) QueryDeploymentStatistics(r *Repo) *DeploymentStatisticsQuery {
	query := &DeploymentStatisticsQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(repo.Table, repo.FieldID, id),
			sqlgraph.To(deploymentstatistics.Table, deploymentstatistics.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repo.DeploymentStatisticsTable, repo.DeploymentStatisticsColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// Hooks returns the client hooks.
func (c *RepoClient) Hooks() []Hook {
	return c.hooks.Repo
}

// ReviewClient is a client for the Review schema.
type ReviewClient struct {
	config
}

// NewReviewClient returns a client for the Review from the given config.
func NewReviewClient(c config) *ReviewClient {
	return &ReviewClient{config: c}
}

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

// Create returns a create builder for Review.
func (c *ReviewClient) Create() *ReviewCreate {
	mutation := newReviewMutation(c.config, OpCreate)
	return &ReviewCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Review entities.
func (c *ReviewClient) CreateBulk(builders ...*ReviewCreate) *ReviewCreateBulk {
	return &ReviewCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Review.
func (c *ReviewClient) Update() *ReviewUpdate {
	mutation := newReviewMutation(c.config, OpUpdate)
	return &ReviewUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ReviewClient) UpdateOne(r *Review) *ReviewUpdateOne {
	mutation := newReviewMutation(c.config, OpUpdateOne, withReview(r))
	return &ReviewUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ReviewClient) UpdateOneID(id int) *ReviewUpdateOne {
	mutation := newReviewMutation(c.config, OpUpdateOne, withReviewID(id))
	return &ReviewUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Review.
func (c *ReviewClient) Delete() *ReviewDelete {
	mutation := newReviewMutation(c.config, OpDelete)
	return &ReviewDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ReviewClient) DeleteOne(r *Review) *ReviewDeleteOne {
	return c.DeleteOneID(r.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ReviewClient) DeleteOneID(id int) *ReviewDeleteOne {
	builder := c.Delete().Where(review.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ReviewDeleteOne{builder}
}

// Query returns a query builder for Review.
func (c *ReviewClient) Query() *ReviewQuery {
	return &ReviewQuery{
		config: c.config,
	}
}

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

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

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

// QueryDeployment queries the deployment edge of a Review.
func (c *ReviewClient) QueryDeployment(r *Review) *DeploymentQuery {
	query := &DeploymentQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(review.Table, review.FieldID, id),
			sqlgraph.To(deployment.Table, deployment.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, review.DeploymentTable, review.DeploymentColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEvent queries the event edge of a Review.
func (c *ReviewClient) QueryEvent(r *Review) *EventQuery {
	query := &EventQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := r.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(review.Table, review.FieldID, id),
			sqlgraph.To(event.Table, event.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, review.EventTable, review.EventColumn),
		)
		fromV = sqlgraph.Neighbors(r.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *ReviewClient) Hooks() []Hook {
	return c.hooks.Review
}

// 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 create builder for User.
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 int64) *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 delete builder for the given entity.
func (c *UserClient) DeleteOne(u *User) *UserDeleteOne {
	return c.DeleteOneID(u.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *UserClient) DeleteOneID(id int64) *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 int64) (*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 int64) *User {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryChatUser queries the chat_user edge of a User.
func (c *UserClient) QueryChatUser(u *User) *ChatUserQuery {
	query := &ChatUserQuery{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(chatuser.Table, chatuser.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, user.ChatUserTable, user.ChatUserColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPerms queries the perms edge of a User.
func (c *UserClient) QueryPerms(u *User) *PermQuery {
	query := &PermQuery{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(perm.Table, perm.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.PermsTable, user.PermsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDeployments queries the deployments edge of a User.
func (c *UserClient) QueryDeployments(u *User) *DeploymentQuery {
	query := &DeploymentQuery{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(deployment.Table, deployment.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.DeploymentsTable, user.DeploymentsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryReviews queries the reviews edge of a User.
func (c *UserClient) QueryReviews(u *User) *ReviewQuery {
	query := &ReviewQuery{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(review.Table, review.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.ReviewsTable, user.ReviewsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLocks queries the locks edge of a User.
func (c *UserClient) QueryLocks(u *User) *LockQuery {
	query := &LockQuery{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(lock.Table, lock.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.LocksTable, user.LocksColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRepos queries the repos edge of a User.
func (c *UserClient) QueryRepos(u *User) *RepoQuery {
	query := &RepoQuery{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(repo.Table, repo.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.ReposTable, user.ReposColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *UserClient) Hooks() []Hook {
	return c.hooks.User
}