client.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"log"

	"github.com/BradHacker/compsole/ent/migrate"
	"github.com/google/uuid"

	"github.com/BradHacker/compsole/ent/action"
	"github.com/BradHacker/compsole/ent/competition"
	"github.com/BradHacker/compsole/ent/provider"
	"github.com/BradHacker/compsole/ent/serviceaccount"
	"github.com/BradHacker/compsole/ent/servicetoken"
	"github.com/BradHacker/compsole/ent/team"
	"github.com/BradHacker/compsole/ent/token"
	"github.com/BradHacker/compsole/ent/user"
	"github.com/BradHacker/compsole/ent/vmobject"

	"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
	// Action is the client for interacting with the Action builders.
	Action *ActionClient
	// Competition is the client for interacting with the Competition builders.
	Competition *CompetitionClient
	// Provider is the client for interacting with the Provider builders.
	Provider *ProviderClient
	// ServiceAccount is the client for interacting with the ServiceAccount builders.
	ServiceAccount *ServiceAccountClient
	// ServiceToken is the client for interacting with the ServiceToken builders.
	ServiceToken *ServiceTokenClient
	// Team is the client for interacting with the Team builders.
	Team *TeamClient
	// Token is the client for interacting with the Token builders.
	Token *TokenClient
	// User is the client for interacting with the User builders.
	User *UserClient
	// VmObject is the client for interacting with the VmObject builders.
	VmObject *VmObjectClient
}

// 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.Action = NewActionClient(c.config)
	c.Competition = NewCompetitionClient(c.config)
	c.Provider = NewProviderClient(c.config)
	c.ServiceAccount = NewServiceAccountClient(c.config)
	c.ServiceToken = NewServiceTokenClient(c.config)
	c.Team = NewTeamClient(c.config)
	c.Token = NewTokenClient(c.config)
	c.User = NewUserClient(c.config)
	c.VmObject = NewVmObjectClient(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,
		Action:         NewActionClient(cfg),
		Competition:    NewCompetitionClient(cfg),
		Provider:       NewProviderClient(cfg),
		ServiceAccount: NewServiceAccountClient(cfg),
		ServiceToken:   NewServiceTokenClient(cfg),
		Team:           NewTeamClient(cfg),
		Token:          NewTokenClient(cfg),
		User:           NewUserClient(cfg),
		VmObject:       NewVmObjectClient(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,
		Action:         NewActionClient(cfg),
		Competition:    NewCompetitionClient(cfg),
		Provider:       NewProviderClient(cfg),
		ServiceAccount: NewServiceAccountClient(cfg),
		ServiceToken:   NewServiceTokenClient(cfg),
		Team:           NewTeamClient(cfg),
		Token:          NewTokenClient(cfg),
		User:           NewUserClient(cfg),
		VmObject:       NewVmObjectClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		Action.
//		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.Action.Use(hooks...)
	c.Competition.Use(hooks...)
	c.Provider.Use(hooks...)
	c.ServiceAccount.Use(hooks...)
	c.ServiceToken.Use(hooks...)
	c.Team.Use(hooks...)
	c.Token.Use(hooks...)
	c.User.Use(hooks...)
	c.VmObject.Use(hooks...)
}

// ActionClient is a client for the Action schema.
type ActionClient struct {
	config
}

// NewActionClient returns a client for the Action from the given config.
func NewActionClient(c config) *ActionClient {
	return &ActionClient{config: c}
}

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

// Create returns a create builder for Action.
func (c *ActionClient) Create() *ActionCreate {
	mutation := newActionMutation(c.config, OpCreate)
	return &ActionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Action entities.
func (c *ActionClient) CreateBulk(builders ...*ActionCreate) *ActionCreateBulk {
	return &ActionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Action.
func (c *ActionClient) Update() *ActionUpdate {
	mutation := newActionMutation(c.config, OpUpdate)
	return &ActionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ActionClient) UpdateOne(a *Action) *ActionUpdateOne {
	mutation := newActionMutation(c.config, OpUpdateOne, withAction(a))
	return &ActionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ActionClient) UpdateOneID(id uuid.UUID) *ActionUpdateOne {
	mutation := newActionMutation(c.config, OpUpdateOne, withActionID(id))
	return &ActionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Action.
func (c *ActionClient) Delete() *ActionDelete {
	mutation := newActionMutation(c.config, OpDelete)
	return &ActionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ActionClient) DeleteOne(a *Action) *ActionDeleteOne {
	return c.DeleteOneID(a.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ActionClient) DeleteOneID(id uuid.UUID) *ActionDeleteOne {
	builder := c.Delete().Where(action.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ActionDeleteOne{builder}
}

// Query returns a query builder for Action.
func (c *ActionClient) Query() *ActionQuery {
	return &ActionQuery{
		config: c.config,
	}
}

// Get returns a Action entity by its id.
func (c *ActionClient) Get(ctx context.Context, id uuid.UUID) (*Action, error) {
	return c.Query().Where(action.ID(id)).Only(ctx)
}

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

// QueryActionToUser queries the ActionToUser edge of a Action.
func (c *ActionClient) QueryActionToUser(a *Action) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(action.Table, action.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, action.ActionToUserTable, action.ActionToUserColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryActionToServiceAccount queries the ActionToServiceAccount edge of a Action.
func (c *ActionClient) QueryActionToServiceAccount(a *Action) *ServiceAccountQuery {
	query := &ServiceAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(action.Table, action.FieldID, id),
			sqlgraph.To(serviceaccount.Table, serviceaccount.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, action.ActionToServiceAccountTable, action.ActionToServiceAccountColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// CompetitionClient is a client for the Competition schema.
type CompetitionClient struct {
	config
}

// NewCompetitionClient returns a client for the Competition from the given config.
func NewCompetitionClient(c config) *CompetitionClient {
	return &CompetitionClient{config: c}
}

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

// Create returns a create builder for Competition.
func (c *CompetitionClient) Create() *CompetitionCreate {
	mutation := newCompetitionMutation(c.config, OpCreate)
	return &CompetitionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Competition entities.
func (c *CompetitionClient) CreateBulk(builders ...*CompetitionCreate) *CompetitionCreateBulk {
	return &CompetitionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Competition.
func (c *CompetitionClient) Update() *CompetitionUpdate {
	mutation := newCompetitionMutation(c.config, OpUpdate)
	return &CompetitionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CompetitionClient) UpdateOne(co *Competition) *CompetitionUpdateOne {
	mutation := newCompetitionMutation(c.config, OpUpdateOne, withCompetition(co))
	return &CompetitionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CompetitionClient) UpdateOneID(id uuid.UUID) *CompetitionUpdateOne {
	mutation := newCompetitionMutation(c.config, OpUpdateOne, withCompetitionID(id))
	return &CompetitionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Competition.
func (c *CompetitionClient) Delete() *CompetitionDelete {
	mutation := newCompetitionMutation(c.config, OpDelete)
	return &CompetitionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *CompetitionClient) DeleteOne(co *Competition) *CompetitionDeleteOne {
	return c.DeleteOneID(co.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *CompetitionClient) DeleteOneID(id uuid.UUID) *CompetitionDeleteOne {
	builder := c.Delete().Where(competition.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CompetitionDeleteOne{builder}
}

// Query returns a query builder for Competition.
func (c *CompetitionClient) Query() *CompetitionQuery {
	return &CompetitionQuery{
		config: c.config,
	}
}

// Get returns a Competition entity by its id.
func (c *CompetitionClient) Get(ctx context.Context, id uuid.UUID) (*Competition, error) {
	return c.Query().Where(competition.ID(id)).Only(ctx)
}

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

// QueryCompetitionToTeams queries the CompetitionToTeams edge of a Competition.
func (c *CompetitionClient) QueryCompetitionToTeams(co *Competition) *TeamQuery {
	query := &TeamQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(competition.Table, competition.FieldID, id),
			sqlgraph.To(team.Table, team.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, competition.CompetitionToTeamsTable, competition.CompetitionToTeamsColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCompetitionToProvider queries the CompetitionToProvider edge of a Competition.
func (c *CompetitionClient) QueryCompetitionToProvider(co *Competition) *ProviderQuery {
	query := &ProviderQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(competition.Table, competition.FieldID, id),
			sqlgraph.To(provider.Table, provider.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, competition.CompetitionToProviderTable, competition.CompetitionToProviderColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// ProviderClient is a client for the Provider schema.
type ProviderClient struct {
	config
}

// NewProviderClient returns a client for the Provider from the given config.
func NewProviderClient(c config) *ProviderClient {
	return &ProviderClient{config: c}
}

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

// Create returns a create builder for Provider.
func (c *ProviderClient) Create() *ProviderCreate {
	mutation := newProviderMutation(c.config, OpCreate)
	return &ProviderCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Provider entities.
func (c *ProviderClient) CreateBulk(builders ...*ProviderCreate) *ProviderCreateBulk {
	return &ProviderCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Provider.
func (c *ProviderClient) Update() *ProviderUpdate {
	mutation := newProviderMutation(c.config, OpUpdate)
	return &ProviderUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProviderClient) UpdateOne(pr *Provider) *ProviderUpdateOne {
	mutation := newProviderMutation(c.config, OpUpdateOne, withProvider(pr))
	return &ProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProviderClient) UpdateOneID(id uuid.UUID) *ProviderUpdateOne {
	mutation := newProviderMutation(c.config, OpUpdateOne, withProviderID(id))
	return &ProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Provider.
func (c *ProviderClient) Delete() *ProviderDelete {
	mutation := newProviderMutation(c.config, OpDelete)
	return &ProviderDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ProviderClient) DeleteOne(pr *Provider) *ProviderDeleteOne {
	return c.DeleteOneID(pr.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ProviderClient) DeleteOneID(id uuid.UUID) *ProviderDeleteOne {
	builder := c.Delete().Where(provider.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ProviderDeleteOne{builder}
}

// Query returns a query builder for Provider.
func (c *ProviderClient) Query() *ProviderQuery {
	return &ProviderQuery{
		config: c.config,
	}
}

// Get returns a Provider entity by its id.
func (c *ProviderClient) Get(ctx context.Context, id uuid.UUID) (*Provider, error) {
	return c.Query().Where(provider.ID(id)).Only(ctx)
}

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

// QueryProviderToCompetitions queries the ProviderToCompetitions edge of a Provider.
func (c *ProviderClient) QueryProviderToCompetitions(pr *Provider) *CompetitionQuery {
	query := &CompetitionQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(provider.Table, provider.FieldID, id),
			sqlgraph.To(competition.Table, competition.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, provider.ProviderToCompetitionsTable, provider.ProviderToCompetitionsColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// ServiceAccountClient is a client for the ServiceAccount schema.
type ServiceAccountClient struct {
	config
}

// NewServiceAccountClient returns a client for the ServiceAccount from the given config.
func NewServiceAccountClient(c config) *ServiceAccountClient {
	return &ServiceAccountClient{config: c}
}

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

// Create returns a create builder for ServiceAccount.
func (c *ServiceAccountClient) Create() *ServiceAccountCreate {
	mutation := newServiceAccountMutation(c.config, OpCreate)
	return &ServiceAccountCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ServiceAccount entities.
func (c *ServiceAccountClient) CreateBulk(builders ...*ServiceAccountCreate) *ServiceAccountCreateBulk {
	return &ServiceAccountCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ServiceAccount.
func (c *ServiceAccountClient) Update() *ServiceAccountUpdate {
	mutation := newServiceAccountMutation(c.config, OpUpdate)
	return &ServiceAccountUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ServiceAccountClient) UpdateOne(sa *ServiceAccount) *ServiceAccountUpdateOne {
	mutation := newServiceAccountMutation(c.config, OpUpdateOne, withServiceAccount(sa))
	return &ServiceAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ServiceAccountClient) UpdateOneID(id uuid.UUID) *ServiceAccountUpdateOne {
	mutation := newServiceAccountMutation(c.config, OpUpdateOne, withServiceAccountID(id))
	return &ServiceAccountUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ServiceAccount.
func (c *ServiceAccountClient) Delete() *ServiceAccountDelete {
	mutation := newServiceAccountMutation(c.config, OpDelete)
	return &ServiceAccountDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ServiceAccountClient) DeleteOne(sa *ServiceAccount) *ServiceAccountDeleteOne {
	return c.DeleteOneID(sa.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ServiceAccountClient) DeleteOneID(id uuid.UUID) *ServiceAccountDeleteOne {
	builder := c.Delete().Where(serviceaccount.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ServiceAccountDeleteOne{builder}
}

// Query returns a query builder for ServiceAccount.
func (c *ServiceAccountClient) Query() *ServiceAccountQuery {
	return &ServiceAccountQuery{
		config: c.config,
	}
}

// Get returns a ServiceAccount entity by its id.
func (c *ServiceAccountClient) Get(ctx context.Context, id uuid.UUID) (*ServiceAccount, error) {
	return c.Query().Where(serviceaccount.ID(id)).Only(ctx)
}

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

// QueryServiceAccountToToken queries the ServiceAccountToToken edge of a ServiceAccount.
func (c *ServiceAccountClient) QueryServiceAccountToToken(sa *ServiceAccount) *ServiceTokenQuery {
	query := &ServiceTokenQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := sa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(serviceaccount.Table, serviceaccount.FieldID, id),
			sqlgraph.To(servicetoken.Table, servicetoken.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, serviceaccount.ServiceAccountToTokenTable, serviceaccount.ServiceAccountToTokenColumn),
		)
		fromV = sqlgraph.Neighbors(sa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryServiceAccountToActions queries the ServiceAccountToActions edge of a ServiceAccount.
func (c *ServiceAccountClient) QueryServiceAccountToActions(sa *ServiceAccount) *ActionQuery {
	query := &ActionQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := sa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(serviceaccount.Table, serviceaccount.FieldID, id),
			sqlgraph.To(action.Table, action.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, serviceaccount.ServiceAccountToActionsTable, serviceaccount.ServiceAccountToActionsColumn),
		)
		fromV = sqlgraph.Neighbors(sa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// ServiceTokenClient is a client for the ServiceToken schema.
type ServiceTokenClient struct {
	config
}

// NewServiceTokenClient returns a client for the ServiceToken from the given config.
func NewServiceTokenClient(c config) *ServiceTokenClient {
	return &ServiceTokenClient{config: c}
}

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

// Create returns a create builder for ServiceToken.
func (c *ServiceTokenClient) Create() *ServiceTokenCreate {
	mutation := newServiceTokenMutation(c.config, OpCreate)
	return &ServiceTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of ServiceToken entities.
func (c *ServiceTokenClient) CreateBulk(builders ...*ServiceTokenCreate) *ServiceTokenCreateBulk {
	return &ServiceTokenCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for ServiceToken.
func (c *ServiceTokenClient) Update() *ServiceTokenUpdate {
	mutation := newServiceTokenMutation(c.config, OpUpdate)
	return &ServiceTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ServiceTokenClient) UpdateOne(st *ServiceToken) *ServiceTokenUpdateOne {
	mutation := newServiceTokenMutation(c.config, OpUpdateOne, withServiceToken(st))
	return &ServiceTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ServiceTokenClient) UpdateOneID(id uuid.UUID) *ServiceTokenUpdateOne {
	mutation := newServiceTokenMutation(c.config, OpUpdateOne, withServiceTokenID(id))
	return &ServiceTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for ServiceToken.
func (c *ServiceTokenClient) Delete() *ServiceTokenDelete {
	mutation := newServiceTokenMutation(c.config, OpDelete)
	return &ServiceTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *ServiceTokenClient) DeleteOne(st *ServiceToken) *ServiceTokenDeleteOne {
	return c.DeleteOneID(st.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *ServiceTokenClient) DeleteOneID(id uuid.UUID) *ServiceTokenDeleteOne {
	builder := c.Delete().Where(servicetoken.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &ServiceTokenDeleteOne{builder}
}

// Query returns a query builder for ServiceToken.
func (c *ServiceTokenClient) Query() *ServiceTokenQuery {
	return &ServiceTokenQuery{
		config: c.config,
	}
}

// Get returns a ServiceToken entity by its id.
func (c *ServiceTokenClient) Get(ctx context.Context, id uuid.UUID) (*ServiceToken, error) {
	return c.Query().Where(servicetoken.ID(id)).Only(ctx)
}

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

// QueryTokenToServiceAccount queries the TokenToServiceAccount edge of a ServiceToken.
func (c *ServiceTokenClient) QueryTokenToServiceAccount(st *ServiceToken) *ServiceAccountQuery {
	query := &ServiceAccountQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := st.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(servicetoken.Table, servicetoken.FieldID, id),
			sqlgraph.To(serviceaccount.Table, serviceaccount.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, servicetoken.TokenToServiceAccountTable, servicetoken.TokenToServiceAccountColumn),
		)
		fromV = sqlgraph.Neighbors(st.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// TeamClient is a client for the Team schema.
type TeamClient struct {
	config
}

// NewTeamClient returns a client for the Team from the given config.
func NewTeamClient(c config) *TeamClient {
	return &TeamClient{config: c}
}

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

// Create returns a create builder for Team.
func (c *TeamClient) Create() *TeamCreate {
	mutation := newTeamMutation(c.config, OpCreate)
	return &TeamCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Team entities.
func (c *TeamClient) CreateBulk(builders ...*TeamCreate) *TeamCreateBulk {
	return &TeamCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Team.
func (c *TeamClient) Update() *TeamUpdate {
	mutation := newTeamMutation(c.config, OpUpdate)
	return &TeamUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TeamClient) UpdateOne(t *Team) *TeamUpdateOne {
	mutation := newTeamMutation(c.config, OpUpdateOne, withTeam(t))
	return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TeamClient) UpdateOneID(id uuid.UUID) *TeamUpdateOne {
	mutation := newTeamMutation(c.config, OpUpdateOne, withTeamID(id))
	return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Team.
func (c *TeamClient) Delete() *TeamDelete {
	mutation := newTeamMutation(c.config, OpDelete)
	return &TeamDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *TeamClient) DeleteOne(t *Team) *TeamDeleteOne {
	return c.DeleteOneID(t.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *TeamClient) DeleteOneID(id uuid.UUID) *TeamDeleteOne {
	builder := c.Delete().Where(team.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TeamDeleteOne{builder}
}

// Query returns a query builder for Team.
func (c *TeamClient) Query() *TeamQuery {
	return &TeamQuery{
		config: c.config,
	}
}

// Get returns a Team entity by its id.
func (c *TeamClient) Get(ctx context.Context, id uuid.UUID) (*Team, error) {
	return c.Query().Where(team.ID(id)).Only(ctx)
}

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

// QueryTeamToCompetition queries the TeamToCompetition edge of a Team.
func (c *TeamClient) QueryTeamToCompetition(t *Team) *CompetitionQuery {
	query := &CompetitionQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(team.Table, team.FieldID, id),
			sqlgraph.To(competition.Table, competition.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, team.TeamToCompetitionTable, team.TeamToCompetitionColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTeamToVmObjects queries the TeamToVmObjects edge of a Team.
func (c *TeamClient) QueryTeamToVmObjects(t *Team) *VmObjectQuery {
	query := &VmObjectQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(team.Table, team.FieldID, id),
			sqlgraph.To(vmobject.Table, vmobject.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, team.TeamToVmObjectsTable, team.TeamToVmObjectsColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTeamToUsers queries the TeamToUsers edge of a Team.
func (c *TeamClient) QueryTeamToUsers(t *Team) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(team.Table, team.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, team.TeamToUsersTable, team.TeamToUsersColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// TokenClient is a client for the Token schema.
type TokenClient struct {
	config
}

// NewTokenClient returns a client for the Token from the given config.
func NewTokenClient(c config) *TokenClient {
	return &TokenClient{config: c}
}

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

// Create returns a create builder for Token.
func (c *TokenClient) Create() *TokenCreate {
	mutation := newTokenMutation(c.config, OpCreate)
	return &TokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Token entities.
func (c *TokenClient) CreateBulk(builders ...*TokenCreate) *TokenCreateBulk {
	return &TokenCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Token.
func (c *TokenClient) Update() *TokenUpdate {
	mutation := newTokenMutation(c.config, OpUpdate)
	return &TokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TokenClient) UpdateOne(t *Token) *TokenUpdateOne {
	mutation := newTokenMutation(c.config, OpUpdateOne, withToken(t))
	return &TokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TokenClient) UpdateOneID(id uuid.UUID) *TokenUpdateOne {
	mutation := newTokenMutation(c.config, OpUpdateOne, withTokenID(id))
	return &TokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Token.
func (c *TokenClient) Delete() *TokenDelete {
	mutation := newTokenMutation(c.config, OpDelete)
	return &TokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *TokenClient) DeleteOne(t *Token) *TokenDeleteOne {
	return c.DeleteOneID(t.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *TokenClient) DeleteOneID(id uuid.UUID) *TokenDeleteOne {
	builder := c.Delete().Where(token.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TokenDeleteOne{builder}
}

// Query returns a query builder for Token.
func (c *TokenClient) Query() *TokenQuery {
	return &TokenQuery{
		config: c.config,
	}
}

// Get returns a Token entity by its id.
func (c *TokenClient) Get(ctx context.Context, id uuid.UUID) (*Token, error) {
	return c.Query().Where(token.ID(id)).Only(ctx)
}

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

// QueryTokenToUser queries the TokenToUser edge of a Token.
func (c *TokenClient) QueryTokenToUser(t *Token) *UserQuery {
	query := &UserQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := t.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(token.Table, token.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, token.TokenToUserTable, token.TokenToUserColumn),
		)
		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// 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 uuid.UUID) *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 uuid.UUID) *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 uuid.UUID) (*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 uuid.UUID) *User {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryUserToTeam queries the UserToTeam edge of a User.
func (c *UserClient) QueryUserToTeam(u *User) *TeamQuery {
	query := &TeamQuery{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(team.Table, team.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, user.UserToTeamTable, user.UserToTeamColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryUserToToken queries the UserToToken edge of a User.
func (c *UserClient) QueryUserToToken(u *User) *TokenQuery {
	query := &TokenQuery{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(token.Table, token.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.UserToTokenTable, user.UserToTokenColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryUserToActions queries the UserToActions edge of a User.
func (c *UserClient) QueryUserToActions(u *User) *ActionQuery {
	query := &ActionQuery{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(action.Table, action.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.UserToActionsTable, user.UserToActionsColumn),
		)
		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
}

// VmObjectClient is a client for the VmObject schema.
type VmObjectClient struct {
	config
}

// NewVmObjectClient returns a client for the VmObject from the given config.
func NewVmObjectClient(c config) *VmObjectClient {
	return &VmObjectClient{config: c}
}

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

// Create returns a create builder for VmObject.
func (c *VmObjectClient) Create() *VmObjectCreate {
	mutation := newVmObjectMutation(c.config, OpCreate)
	return &VmObjectCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of VmObject entities.
func (c *VmObjectClient) CreateBulk(builders ...*VmObjectCreate) *VmObjectCreateBulk {
	return &VmObjectCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for VmObject.
func (c *VmObjectClient) Update() *VmObjectUpdate {
	mutation := newVmObjectMutation(c.config, OpUpdate)
	return &VmObjectUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *VmObjectClient) UpdateOne(vo *VmObject) *VmObjectUpdateOne {
	mutation := newVmObjectMutation(c.config, OpUpdateOne, withVmObject(vo))
	return &VmObjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *VmObjectClient) UpdateOneID(id uuid.UUID) *VmObjectUpdateOne {
	mutation := newVmObjectMutation(c.config, OpUpdateOne, withVmObjectID(id))
	return &VmObjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for VmObject.
func (c *VmObjectClient) Delete() *VmObjectDelete {
	mutation := newVmObjectMutation(c.config, OpDelete)
	return &VmObjectDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *VmObjectClient) DeleteOne(vo *VmObject) *VmObjectDeleteOne {
	return c.DeleteOneID(vo.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *VmObjectClient) DeleteOneID(id uuid.UUID) *VmObjectDeleteOne {
	builder := c.Delete().Where(vmobject.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &VmObjectDeleteOne{builder}
}

// Query returns a query builder for VmObject.
func (c *VmObjectClient) Query() *VmObjectQuery {
	return &VmObjectQuery{
		config: c.config,
	}
}

// Get returns a VmObject entity by its id.
func (c *VmObjectClient) Get(ctx context.Context, id uuid.UUID) (*VmObject, error) {
	return c.Query().Where(vmobject.ID(id)).Only(ctx)
}

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

// QueryVmObjectToTeam queries the VmObjectToTeam edge of a VmObject.
func (c *VmObjectClient) QueryVmObjectToTeam(vo *VmObject) *TeamQuery {
	query := &TeamQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := vo.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vmobject.Table, vmobject.FieldID, id),
			sqlgraph.To(team.Table, team.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, vmobject.VmObjectToTeamTable, vmobject.VmObjectToTeamColumn),
		)
		fromV = sqlgraph.Neighbors(vo.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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