client.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"log"

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

	"github.com/gitploy-io/gitploy/ent/approval"
	"github.com/gitploy-io/gitploy/ent/callback"
	"github.com/gitploy-io/gitploy/ent/chatuser"
	"github.com/gitploy-io/gitploy/ent/deployment"
	"github.com/gitploy-io/gitploy/ent/deploymentcount"
	"github.com/gitploy-io/gitploy/ent/deploymentstatus"
	"github.com/gitploy-io/gitploy/ent/event"
	"github.com/gitploy-io/gitploy/ent/lock"
	"github.com/gitploy-io/gitploy/ent/notificationrecord"
	"github.com/gitploy-io/gitploy/ent/perm"
	"github.com/gitploy-io/gitploy/ent/repo"
	"github.com/gitploy-io/gitploy/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
	// Approval is the client for interacting with the Approval builders.
	Approval *ApprovalClient
	// Callback is the client for interacting with the Callback builders.
	Callback *CallbackClient
	// ChatUser is the client for interacting with the ChatUser builders.
	ChatUser *ChatUserClient
	// Deployment is the client for interacting with the Deployment builders.
	Deployment *DeploymentClient
	// DeploymentCount is the client for interacting with the DeploymentCount builders.
	DeploymentCount *DeploymentCountClient
	// 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
	// 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.Approval = NewApprovalClient(c.config)
	c.Callback = NewCallbackClient(c.config)
	c.ChatUser = NewChatUserClient(c.config)
	c.Deployment = NewDeploymentClient(c.config)
	c.DeploymentCount = NewDeploymentCountClient(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.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,
		Approval:           NewApprovalClient(cfg),
		Callback:           NewCallbackClient(cfg),
		ChatUser:           NewChatUserClient(cfg),
		Deployment:         NewDeploymentClient(cfg),
		DeploymentCount:    NewDeploymentCountClient(cfg),
		DeploymentStatus:   NewDeploymentStatusClient(cfg),
		Event:              NewEventClient(cfg),
		Lock:               NewLockClient(cfg),
		NotificationRecord: NewNotificationRecordClient(cfg),
		Perm:               NewPermClient(cfg),
		Repo:               NewRepoClient(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{
		config:             cfg,
		Approval:           NewApprovalClient(cfg),
		Callback:           NewCallbackClient(cfg),
		ChatUser:           NewChatUserClient(cfg),
		Deployment:         NewDeploymentClient(cfg),
		DeploymentCount:    NewDeploymentCountClient(cfg),
		DeploymentStatus:   NewDeploymentStatusClient(cfg),
		Event:              NewEventClient(cfg),
		Lock:               NewLockClient(cfg),
		NotificationRecord: NewNotificationRecordClient(cfg),
		Perm:               NewPermClient(cfg),
		Repo:               NewRepoClient(cfg),
		User:               NewUserClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		Approval.
//		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.Approval.Use(hooks...)
	c.Callback.Use(hooks...)
	c.ChatUser.Use(hooks...)
	c.Deployment.Use(hooks...)
	c.DeploymentCount.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.User.Use(hooks...)
}

// ApprovalClient is a client for the Approval schema.
type ApprovalClient struct {
	config
}

// NewApprovalClient returns a client for the Approval from the given config.
func NewApprovalClient(c config) *ApprovalClient {
	return &ApprovalClient{config: c}
}

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

// Create returns a create builder for Approval.
func (c *ApprovalClient) Create() *ApprovalCreate {
	mutation := newApprovalMutation(c.config, OpCreate)
	return &ApprovalCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Approval entities.
func (c *ApprovalClient) CreateBulk(builders ...*ApprovalCreate) *ApprovalCreateBulk {
	return &ApprovalCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Approval.
func (c *ApprovalClient) Update() *ApprovalUpdate {
	mutation := newApprovalMutation(c.config, OpUpdate)
	return &ApprovalUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ApprovalClient) UpdateOne(a *Approval) *ApprovalUpdateOne {
	mutation := newApprovalMutation(c.config, OpUpdateOne, withApproval(a))
	return &ApprovalUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ApprovalClient) UpdateOneID(id int) *ApprovalUpdateOne {
	mutation := newApprovalMutation(c.config, OpUpdateOne, withApprovalID(id))
	return &ApprovalUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Approval.
func (c *ApprovalClient) Delete() *ApprovalDelete {
	mutation := newApprovalMutation(c.config, OpDelete)
	return &ApprovalDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ApprovalClient) DeleteOne(a *Approval) *ApprovalDeleteOne {
	return c.DeleteOneID(a.ID)
}

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

// Query returns a query builder for Approval.
func (c *ApprovalClient) Query() *ApprovalQuery {
	return &ApprovalQuery{
		config: c.config,
	}
}

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

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

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

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

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

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

// CallbackClient is a client for the Callback schema.
type CallbackClient struct {
	config
}

// NewCallbackClient returns a client for the Callback from the given config.
func NewCallbackClient(c config) *CallbackClient {
	return &CallbackClient{config: c}
}

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

// Create returns a create builder for Callback.
func (c *CallbackClient) Create() *CallbackCreate {
	mutation := newCallbackMutation(c.config, OpCreate)
	return &CallbackCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Callback entities.
func (c *CallbackClient) CreateBulk(builders ...*CallbackCreate) *CallbackCreateBulk {
	return &CallbackCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Callback.
func (c *CallbackClient) Update() *CallbackUpdate {
	mutation := newCallbackMutation(c.config, OpUpdate)
	return &CallbackUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CallbackClient) UpdateOne(ca *Callback) *CallbackUpdateOne {
	mutation := newCallbackMutation(c.config, OpUpdateOne, withCallback(ca))
	return &CallbackUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CallbackClient) UpdateOneID(id int) *CallbackUpdateOne {
	mutation := newCallbackMutation(c.config, OpUpdateOne, withCallbackID(id))
	return &CallbackUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Callback.
func (c *CallbackClient) Delete() *CallbackDelete {
	mutation := newCallbackMutation(c.config, OpDelete)
	return &CallbackDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *CallbackClient) DeleteOne(ca *Callback) *CallbackDeleteOne {
	return c.DeleteOneID(ca.ID)
}

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

// Query returns a query builder for Callback.
func (c *CallbackClient) Query() *CallbackQuery {
	return &CallbackQuery{
		config: c.config,
	}
}

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

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

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

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

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

// QueryApprovals queries the approvals edge of a Deployment.
func (c *DeploymentClient) QueryApprovals(d *Deployment) *ApprovalQuery {
	query := &ApprovalQuery{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(approval.Table, approval.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, deployment.ApprovalsTable, deployment.ApprovalsColumn),
		)
		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
}

// DeploymentCountClient is a client for the DeploymentCount schema.
type DeploymentCountClient struct {
	config
}

// NewDeploymentCountClient returns a client for the DeploymentCount from the given config.
func NewDeploymentCountClient(c config) *DeploymentCountClient {
	return &DeploymentCountClient{config: c}
}

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

// Create returns a create builder for DeploymentCount.
func (c *DeploymentCountClient) Create() *DeploymentCountCreate {
	mutation := newDeploymentCountMutation(c.config, OpCreate)
	return &DeploymentCountCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DeploymentCount entities.
func (c *DeploymentCountClient) CreateBulk(builders ...*DeploymentCountCreate) *DeploymentCountCreateBulk {
	return &DeploymentCountCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DeploymentCount.
func (c *DeploymentCountClient) Update() *DeploymentCountUpdate {
	mutation := newDeploymentCountMutation(c.config, OpUpdate)
	return &DeploymentCountUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeploymentCountClient) UpdateOne(dc *DeploymentCount) *DeploymentCountUpdateOne {
	mutation := newDeploymentCountMutation(c.config, OpUpdateOne, withDeploymentCount(dc))
	return &DeploymentCountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeploymentCountClient) UpdateOneID(id int) *DeploymentCountUpdateOne {
	mutation := newDeploymentCountMutation(c.config, OpUpdateOne, withDeploymentCountID(id))
	return &DeploymentCountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DeploymentCount.
func (c *DeploymentCountClient) Delete() *DeploymentCountDelete {
	mutation := newDeploymentCountMutation(c.config, OpDelete)
	return &DeploymentCountDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeploymentCountClient) DeleteOne(dc *DeploymentCount) *DeploymentCountDeleteOne {
	return c.DeleteOneID(dc.ID)
}

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

// Query returns a query builder for DeploymentCount.
func (c *DeploymentCountClient) Query() *DeploymentCountQuery {
	return &DeploymentCountQuery{
		config: c.config,
	}
}

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

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

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

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

// QueryApproval queries the approval edge of a Event.
func (c *EventClient) QueryApproval(e *Event) *ApprovalQuery {
	query := &ApprovalQuery{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(approval.Table, approval.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, event.ApprovalTable, event.ApprovalColumn),
		)
		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
}

// QueryCallback queries the callback edge of a Repo.
func (c *RepoClient) QueryCallback(r *Repo) *CallbackQuery {
	query := &CallbackQuery{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(callback.Table, callback.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, repo.CallbackTable, repo.CallbackColumn),
		)
		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
}

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

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

// QueryApprovals queries the approvals edge of a User.
func (c *UserClient) QueryApprovals(u *User) *ApprovalQuery {
	query := &ApprovalQuery{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(approval.Table, approval.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.ApprovalsTable, user.ApprovalsColumn),
		)
		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
}

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