client.go

// Code generated by ent, DO NOT EDIT.

package ent

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

	"github.com/woocoos/knockout/ent/migrate"

	"entgo.io/ent"
	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"github.com/woocoos/entcache"
	"github.com/woocoos/knockout/ent/app"
	"github.com/woocoos/knockout/ent/appaction"
	"github.com/woocoos/knockout/ent/appdict"
	"github.com/woocoos/knockout/ent/appdictitem"
	"github.com/woocoos/knockout/ent/appmenu"
	"github.com/woocoos/knockout/ent/apppolicy"
	"github.com/woocoos/knockout/ent/appres"
	"github.com/woocoos/knockout/ent/approle"
	"github.com/woocoos/knockout/ent/approlepolicy"
	"github.com/woocoos/knockout/ent/file"
	"github.com/woocoos/knockout/ent/filesource"
	"github.com/woocoos/knockout/ent/oauthclient"
	"github.com/woocoos/knockout/ent/org"
	"github.com/woocoos/knockout/ent/orgapp"
	"github.com/woocoos/knockout/ent/orgpolicy"
	"github.com/woocoos/knockout/ent/orgrole"
	"github.com/woocoos/knockout/ent/orgroleuser"
	"github.com/woocoos/knockout/ent/orguser"
	"github.com/woocoos/knockout/ent/orguserpreference"
	"github.com/woocoos/knockout/ent/permission"
	"github.com/woocoos/knockout/ent/user"
	"github.com/woocoos/knockout/ent/userdevice"
	"github.com/woocoos/knockout/ent/useridentity"
	"github.com/woocoos/knockout/ent/userloginprofile"
	"github.com/woocoos/knockout/ent/userpassword"
)

// 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
	// App is the client for interacting with the App builders.
	App *AppClient
	// AppAction is the client for interacting with the AppAction builders.
	AppAction *AppActionClient
	// AppDict is the client for interacting with the AppDict builders.
	AppDict *AppDictClient
	// AppDictItem is the client for interacting with the AppDictItem builders.
	AppDictItem *AppDictItemClient
	// AppMenu is the client for interacting with the AppMenu builders.
	AppMenu *AppMenuClient
	// AppPolicy is the client for interacting with the AppPolicy builders.
	AppPolicy *AppPolicyClient
	// AppRes is the client for interacting with the AppRes builders.
	AppRes *AppResClient
	// AppRole is the client for interacting with the AppRole builders.
	AppRole *AppRoleClient
	// AppRolePolicy is the client for interacting with the AppRolePolicy builders.
	AppRolePolicy *AppRolePolicyClient
	// File is the client for interacting with the File builders.
	File *FileClient
	// FileSource is the client for interacting with the FileSource builders.
	FileSource *FileSourceClient
	// OauthClient is the client for interacting with the OauthClient builders.
	OauthClient *OauthClientClient
	// Org is the client for interacting with the Org builders.
	Org *OrgClient
	// OrgApp is the client for interacting with the OrgApp builders.
	OrgApp *OrgAppClient
	// OrgPolicy is the client for interacting with the OrgPolicy builders.
	OrgPolicy *OrgPolicyClient
	// OrgRole is the client for interacting with the OrgRole builders.
	OrgRole *OrgRoleClient
	// OrgRoleUser is the client for interacting with the OrgRoleUser builders.
	OrgRoleUser *OrgRoleUserClient
	// OrgUser is the client for interacting with the OrgUser builders.
	OrgUser *OrgUserClient
	// OrgUserPreference is the client for interacting with the OrgUserPreference builders.
	OrgUserPreference *OrgUserPreferenceClient
	// Permission is the client for interacting with the Permission builders.
	Permission *PermissionClient
	// User is the client for interacting with the User builders.
	User *UserClient
	// UserDevice is the client for interacting with the UserDevice builders.
	UserDevice *UserDeviceClient
	// UserIdentity is the client for interacting with the UserIdentity builders.
	UserIdentity *UserIdentityClient
	// UserLoginProfile is the client for interacting with the UserLoginProfile builders.
	UserLoginProfile *UserLoginProfileClient
	// UserPassword is the client for interacting with the UserPassword builders.
	UserPassword *UserPasswordClient
	// additional fields for node api
	tables tables
}

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

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.App = NewAppClient(c.config)
	c.AppAction = NewAppActionClient(c.config)
	c.AppDict = NewAppDictClient(c.config)
	c.AppDictItem = NewAppDictItemClient(c.config)
	c.AppMenu = NewAppMenuClient(c.config)
	c.AppPolicy = NewAppPolicyClient(c.config)
	c.AppRes = NewAppResClient(c.config)
	c.AppRole = NewAppRoleClient(c.config)
	c.AppRolePolicy = NewAppRolePolicyClient(c.config)
	c.File = NewFileClient(c.config)
	c.FileSource = NewFileSourceClient(c.config)
	c.OauthClient = NewOauthClientClient(c.config)
	c.Org = NewOrgClient(c.config)
	c.OrgApp = NewOrgAppClient(c.config)
	c.OrgPolicy = NewOrgPolicyClient(c.config)
	c.OrgRole = NewOrgRoleClient(c.config)
	c.OrgRoleUser = NewOrgRoleUserClient(c.config)
	c.OrgUser = NewOrgUserClient(c.config)
	c.OrgUserPreference = NewOrgUserPreferenceClient(c.config)
	c.Permission = NewPermissionClient(c.config)
	c.User = NewUserClient(c.config)
	c.UserDevice = NewUserDeviceClient(c.config)
	c.UserIdentity = NewUserIdentityClient(c.config)
	c.UserLoginProfile = NewUserLoginProfileClient(c.config)
	c.UserPassword = NewUserPasswordClient(c.config)
}

type (
	// config is the configuration for the client and its builder.
	config struct {
		// driver used for executing database requests.
		driver dialect.Driver
		// debug enable a debug logging.
		debug bool
		// log used for logging on debug mode.
		log func(...any)
		// hooks to execute on mutations.
		hooks *hooks
		// interceptors to execute on queries.
		inters *inters
	}
	// Option function to configure the client.
	Option func(*config)
)

// options applies the options on the config object.
func (c *config) options(opts ...Option) {
	for _, opt := range opts {
		opt(c)
	}
	if c.debug {
		c.driver = dialect.Debug(c.driver, c.log)
	}
}

// Debug enables debug logging on the ent.Driver.
func Debug() Option {
	return func(c *config) {
		c.debug = true
	}
}

// Log sets the logging function for debug mode.
func Log(fn func(...any)) Option {
	return func(c *config) {
		c.log = fn
	}
}

// Driver configures the client driver.
func Driver(driver dialect.Driver) Option {
	return func(c *config) {
		c.driver = driver
	}
}

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

// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")

// 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, ErrTxStarted
	}
	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,
		App:               NewAppClient(cfg),
		AppAction:         NewAppActionClient(cfg),
		AppDict:           NewAppDictClient(cfg),
		AppDictItem:       NewAppDictItemClient(cfg),
		AppMenu:           NewAppMenuClient(cfg),
		AppPolicy:         NewAppPolicyClient(cfg),
		AppRes:            NewAppResClient(cfg),
		AppRole:           NewAppRoleClient(cfg),
		AppRolePolicy:     NewAppRolePolicyClient(cfg),
		File:              NewFileClient(cfg),
		FileSource:        NewFileSourceClient(cfg),
		OauthClient:       NewOauthClientClient(cfg),
		Org:               NewOrgClient(cfg),
		OrgApp:            NewOrgAppClient(cfg),
		OrgPolicy:         NewOrgPolicyClient(cfg),
		OrgRole:           NewOrgRoleClient(cfg),
		OrgRoleUser:       NewOrgRoleUserClient(cfg),
		OrgUser:           NewOrgUserClient(cfg),
		OrgUserPreference: NewOrgUserPreferenceClient(cfg),
		Permission:        NewPermissionClient(cfg),
		User:              NewUserClient(cfg),
		UserDevice:        NewUserDeviceClient(cfg),
		UserIdentity:      NewUserIdentityClient(cfg),
		UserLoginProfile:  NewUserLoginProfileClient(cfg),
		UserPassword:      NewUserPasswordClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := c.driver.(interface {
		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
	}).BeginTx(ctx, opts)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = &txDriver{tx: tx, drv: c.driver}
	return &Tx{
		ctx:               ctx,
		config:            cfg,
		App:               NewAppClient(cfg),
		AppAction:         NewAppActionClient(cfg),
		AppDict:           NewAppDictClient(cfg),
		AppDictItem:       NewAppDictItemClient(cfg),
		AppMenu:           NewAppMenuClient(cfg),
		AppPolicy:         NewAppPolicyClient(cfg),
		AppRes:            NewAppResClient(cfg),
		AppRole:           NewAppRoleClient(cfg),
		AppRolePolicy:     NewAppRolePolicyClient(cfg),
		File:              NewFileClient(cfg),
		FileSource:        NewFileSourceClient(cfg),
		OauthClient:       NewOauthClientClient(cfg),
		Org:               NewOrgClient(cfg),
		OrgApp:            NewOrgAppClient(cfg),
		OrgPolicy:         NewOrgPolicyClient(cfg),
		OrgRole:           NewOrgRoleClient(cfg),
		OrgRoleUser:       NewOrgRoleUserClient(cfg),
		OrgUser:           NewOrgUserClient(cfg),
		OrgUserPreference: NewOrgUserPreferenceClient(cfg),
		Permission:        NewPermissionClient(cfg),
		User:              NewUserClient(cfg),
		UserDevice:        NewUserDeviceClient(cfg),
		UserIdentity:      NewUserIdentityClient(cfg),
		UserLoginProfile:  NewUserLoginProfileClient(cfg),
		UserPassword:      NewUserPasswordClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		App.
//		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) {
	for _, n := range []interface{ Use(...Hook) }{
		c.App, c.AppAction, c.AppDict, c.AppDictItem, c.AppMenu, c.AppPolicy, c.AppRes,
		c.AppRole, c.AppRolePolicy, c.File, c.FileSource, c.OauthClient, c.Org,
		c.OrgApp, c.OrgPolicy, c.OrgRole, c.OrgRoleUser, c.OrgUser,
		c.OrgUserPreference, c.Permission, c.User, c.UserDevice, c.UserIdentity,
		c.UserLoginProfile, c.UserPassword,
	} {
		n.Use(hooks...)
	}
}

// Intercept adds the query interceptors to all the entity clients.
// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
func (c *Client) Intercept(interceptors ...Interceptor) {
	for _, n := range []interface{ Intercept(...Interceptor) }{
		c.App, c.AppAction, c.AppDict, c.AppDictItem, c.AppMenu, c.AppPolicy, c.AppRes,
		c.AppRole, c.AppRolePolicy, c.File, c.FileSource, c.OauthClient, c.Org,
		c.OrgApp, c.OrgPolicy, c.OrgRole, c.OrgRoleUser, c.OrgUser,
		c.OrgUserPreference, c.Permission, c.User, c.UserDevice, c.UserIdentity,
		c.UserLoginProfile, c.UserPassword,
	} {
		n.Intercept(interceptors...)
	}
}

// Mutate implements the ent.Mutator interface.
func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
	switch m := m.(type) {
	case *AppMutation:
		return c.App.mutate(ctx, m)
	case *AppActionMutation:
		return c.AppAction.mutate(ctx, m)
	case *AppDictMutation:
		return c.AppDict.mutate(ctx, m)
	case *AppDictItemMutation:
		return c.AppDictItem.mutate(ctx, m)
	case *AppMenuMutation:
		return c.AppMenu.mutate(ctx, m)
	case *AppPolicyMutation:
		return c.AppPolicy.mutate(ctx, m)
	case *AppResMutation:
		return c.AppRes.mutate(ctx, m)
	case *AppRoleMutation:
		return c.AppRole.mutate(ctx, m)
	case *AppRolePolicyMutation:
		return c.AppRolePolicy.mutate(ctx, m)
	case *FileMutation:
		return c.File.mutate(ctx, m)
	case *FileSourceMutation:
		return c.FileSource.mutate(ctx, m)
	case *OauthClientMutation:
		return c.OauthClient.mutate(ctx, m)
	case *OrgMutation:
		return c.Org.mutate(ctx, m)
	case *OrgAppMutation:
		return c.OrgApp.mutate(ctx, m)
	case *OrgPolicyMutation:
		return c.OrgPolicy.mutate(ctx, m)
	case *OrgRoleMutation:
		return c.OrgRole.mutate(ctx, m)
	case *OrgRoleUserMutation:
		return c.OrgRoleUser.mutate(ctx, m)
	case *OrgUserMutation:
		return c.OrgUser.mutate(ctx, m)
	case *OrgUserPreferenceMutation:
		return c.OrgUserPreference.mutate(ctx, m)
	case *PermissionMutation:
		return c.Permission.mutate(ctx, m)
	case *UserMutation:
		return c.User.mutate(ctx, m)
	case *UserDeviceMutation:
		return c.UserDevice.mutate(ctx, m)
	case *UserIdentityMutation:
		return c.UserIdentity.mutate(ctx, m)
	case *UserLoginProfileMutation:
		return c.UserLoginProfile.mutate(ctx, m)
	case *UserPasswordMutation:
		return c.UserPassword.mutate(ctx, m)
	default:
		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
	}
}

// AppClient is a client for the App schema.
type AppClient struct {
	config
}

// NewAppClient returns a client for the App from the given config.
func NewAppClient(c config) *AppClient {
	return &AppClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `app.Intercept(f(g(h())))`.
func (c *AppClient) Intercept(interceptors ...Interceptor) {
	c.inters.App = append(c.inters.App, interceptors...)
}

// Create returns a builder for creating a App entity.
func (c *AppClient) Create() *AppCreate {
	mutation := newAppMutation(c.config, OpCreate)
	return &AppCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of App entities.
func (c *AppClient) CreateBulk(builders ...*AppCreate) *AppCreateBulk {
	return &AppCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppClient) MapCreateBulk(slice any, setFunc func(*AppCreate, int)) *AppCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppCreateBulk{err: fmt.Errorf("calling to AppClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for App.
func (c *AppClient) Update() *AppUpdate {
	mutation := newAppMutation(c.config, OpUpdate)
	return &AppUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppClient) UpdateOne(a *App) *AppUpdateOne {
	mutation := newAppMutation(c.config, OpUpdateOne, withApp(a))
	return &AppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppClient) UpdateOneID(id int) *AppUpdateOne {
	mutation := newAppMutation(c.config, OpUpdateOne, withAppID(id))
	return &AppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for App.
func (c *AppClient) Delete() *AppDelete {
	mutation := newAppMutation(c.config, OpDelete)
	return &AppDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppClient) DeleteOne(a *App) *AppDeleteOne {
	return c.DeleteOneID(a.ID)
}

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

// Query returns a query builder for App.
func (c *AppClient) Query() *AppQuery {
	return &AppQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeApp},
		inters: c.Interceptors(),
	}
}

// Get returns a App entity by its id.
func (c *AppClient) Get(ctx context.Context, id int) (*App, error) {
	return c.Query().Where(app.ID(id)).Only(entcache.WithEntryKey(ctx, "App", id))
}

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

// QueryMenus queries the menus edge of a App.
func (c *AppClient) QueryMenus(a *App) *AppMenuQuery {
	query := (&AppMenuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(appmenu.Table, appmenu.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.MenusTable, app.MenusColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryActions queries the actions edge of a App.
func (c *AppClient) QueryActions(a *App) *AppActionQuery {
	query := (&AppActionClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(appaction.Table, appaction.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.ActionsTable, app.ActionsColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryResources queries the resources edge of a App.
func (c *AppClient) QueryResources(a *App) *AppResQuery {
	query := (&AppResClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(appres.Table, appres.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.ResourcesTable, app.ResourcesColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRoles queries the roles edge of a App.
func (c *AppClient) QueryRoles(a *App) *AppRoleQuery {
	query := (&AppRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(approle.Table, approle.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.RolesTable, app.RolesColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPolicies queries the policies edge of a App.
func (c *AppClient) QueryPolicies(a *App) *AppPolicyQuery {
	query := (&AppPolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(apppolicy.Table, apppolicy.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.PoliciesTable, app.PoliciesColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgs queries the orgs edge of a App.
func (c *AppClient) QueryOrgs(a *App) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, app.OrgsTable, app.OrgsPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDicts queries the dicts edge of a App.
func (c *AppClient) QueryDicts(a *App) *AppDictQuery {
	query := (&AppDictClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(appdict.Table, appdict.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, app.DictsTable, app.DictsColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgApp queries the org_app edge of a App.
func (c *AppClient) QueryOrgApp(a *App) *OrgAppQuery {
	query := (&OrgAppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := a.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(app.Table, app.FieldID, id),
			sqlgraph.To(orgapp.Table, orgapp.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, app.OrgAppTable, app.OrgAppColumn),
		)
		fromV = sqlgraph.Neighbors(a.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppClient) Hooks() []Hook {
	hooks := c.hooks.App
	return append(hooks[:len(hooks):len(hooks)], app.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppClient) Interceptors() []Interceptor {
	return c.inters.App
}

func (c *AppClient) mutate(ctx context.Context, m *AppMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown App mutation op: %q", m.Op())
	}
}

// AppActionClient is a client for the AppAction schema.
type AppActionClient struct {
	config
}

// NewAppActionClient returns a client for the AppAction from the given config.
func NewAppActionClient(c config) *AppActionClient {
	return &AppActionClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `appaction.Intercept(f(g(h())))`.
func (c *AppActionClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppAction = append(c.inters.AppAction, interceptors...)
}

// Create returns a builder for creating a AppAction entity.
func (c *AppActionClient) Create() *AppActionCreate {
	mutation := newAppActionMutation(c.config, OpCreate)
	return &AppActionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppAction entities.
func (c *AppActionClient) CreateBulk(builders ...*AppActionCreate) *AppActionCreateBulk {
	return &AppActionCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppActionClient) MapCreateBulk(slice any, setFunc func(*AppActionCreate, int)) *AppActionCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppActionCreateBulk{err: fmt.Errorf("calling to AppActionClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppActionCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppActionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppAction.
func (c *AppActionClient) Update() *AppActionUpdate {
	mutation := newAppActionMutation(c.config, OpUpdate)
	return &AppActionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppActionClient) UpdateOne(aa *AppAction) *AppActionUpdateOne {
	mutation := newAppActionMutation(c.config, OpUpdateOne, withAppAction(aa))
	return &AppActionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppActionClient) UpdateOneID(id int) *AppActionUpdateOne {
	mutation := newAppActionMutation(c.config, OpUpdateOne, withAppActionID(id))
	return &AppActionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppAction.
func (c *AppActionClient) Delete() *AppActionDelete {
	mutation := newAppActionMutation(c.config, OpDelete)
	return &AppActionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppActionClient) DeleteOne(aa *AppAction) *AppActionDeleteOne {
	return c.DeleteOneID(aa.ID)
}

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

// Query returns a query builder for AppAction.
func (c *AppActionClient) Query() *AppActionQuery {
	return &AppActionQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppAction},
		inters: c.Interceptors(),
	}
}

// Get returns a AppAction entity by its id.
func (c *AppActionClient) Get(ctx context.Context, id int) (*AppAction, error) {
	return c.Query().Where(appaction.ID(id)).Only(entcache.WithEntryKey(ctx, "AppAction", id))
}

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

// QueryApp queries the app edge of a AppAction.
func (c *AppActionClient) QueryApp(aa *AppAction) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := aa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appaction.Table, appaction.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appaction.AppTable, appaction.AppColumn),
		)
		fromV = sqlgraph.Neighbors(aa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryMenus queries the menus edge of a AppAction.
func (c *AppActionClient) QueryMenus(aa *AppAction) *AppMenuQuery {
	query := (&AppMenuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := aa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appaction.Table, appaction.FieldID, id),
			sqlgraph.To(appmenu.Table, appmenu.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, appaction.MenusTable, appaction.MenusColumn),
		)
		fromV = sqlgraph.Neighbors(aa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppActionClient) Hooks() []Hook {
	hooks := c.hooks.AppAction
	return append(hooks[:len(hooks):len(hooks)], appaction.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppActionClient) Interceptors() []Interceptor {
	return c.inters.AppAction
}

func (c *AppActionClient) mutate(ctx context.Context, m *AppActionMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppActionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppActionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppActionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppActionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppAction mutation op: %q", m.Op())
	}
}

// AppDictClient is a client for the AppDict schema.
type AppDictClient struct {
	config
}

// NewAppDictClient returns a client for the AppDict from the given config.
func NewAppDictClient(c config) *AppDictClient {
	return &AppDictClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `appdict.Intercept(f(g(h())))`.
func (c *AppDictClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppDict = append(c.inters.AppDict, interceptors...)
}

// Create returns a builder for creating a AppDict entity.
func (c *AppDictClient) Create() *AppDictCreate {
	mutation := newAppDictMutation(c.config, OpCreate)
	return &AppDictCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppDict entities.
func (c *AppDictClient) CreateBulk(builders ...*AppDictCreate) *AppDictCreateBulk {
	return &AppDictCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppDictClient) MapCreateBulk(slice any, setFunc func(*AppDictCreate, int)) *AppDictCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppDictCreateBulk{err: fmt.Errorf("calling to AppDictClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppDictCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppDictCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppDict.
func (c *AppDictClient) Update() *AppDictUpdate {
	mutation := newAppDictMutation(c.config, OpUpdate)
	return &AppDictUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppDictClient) UpdateOne(ad *AppDict) *AppDictUpdateOne {
	mutation := newAppDictMutation(c.config, OpUpdateOne, withAppDict(ad))
	return &AppDictUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppDictClient) UpdateOneID(id int) *AppDictUpdateOne {
	mutation := newAppDictMutation(c.config, OpUpdateOne, withAppDictID(id))
	return &AppDictUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppDict.
func (c *AppDictClient) Delete() *AppDictDelete {
	mutation := newAppDictMutation(c.config, OpDelete)
	return &AppDictDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppDictClient) DeleteOne(ad *AppDict) *AppDictDeleteOne {
	return c.DeleteOneID(ad.ID)
}

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

// Query returns a query builder for AppDict.
func (c *AppDictClient) Query() *AppDictQuery {
	return &AppDictQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppDict},
		inters: c.Interceptors(),
	}
}

// Get returns a AppDict entity by its id.
func (c *AppDictClient) Get(ctx context.Context, id int) (*AppDict, error) {
	return c.Query().Where(appdict.ID(id)).Only(entcache.WithEntryKey(ctx, "AppDict", id))
}

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

// QueryApp queries the app edge of a AppDict.
func (c *AppDictClient) QueryApp(ad *AppDict) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ad.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appdict.Table, appdict.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appdict.AppTable, appdict.AppColumn),
		)
		fromV = sqlgraph.Neighbors(ad.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryItems queries the items edge of a AppDict.
func (c *AppDictClient) QueryItems(ad *AppDict) *AppDictItemQuery {
	query := (&AppDictItemClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ad.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appdict.Table, appdict.FieldID, id),
			sqlgraph.To(appdictitem.Table, appdictitem.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, appdict.ItemsTable, appdict.ItemsColumn),
		)
		fromV = sqlgraph.Neighbors(ad.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppDictClient) Hooks() []Hook {
	hooks := c.hooks.AppDict
	return append(hooks[:len(hooks):len(hooks)], appdict.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppDictClient) Interceptors() []Interceptor {
	return c.inters.AppDict
}

func (c *AppDictClient) mutate(ctx context.Context, m *AppDictMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppDictCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppDictUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppDictUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppDictDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppDict mutation op: %q", m.Op())
	}
}

// AppDictItemClient is a client for the AppDictItem schema.
type AppDictItemClient struct {
	config
}

// NewAppDictItemClient returns a client for the AppDictItem from the given config.
func NewAppDictItemClient(c config) *AppDictItemClient {
	return &AppDictItemClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `appdictitem.Intercept(f(g(h())))`.
func (c *AppDictItemClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppDictItem = append(c.inters.AppDictItem, interceptors...)
}

// Create returns a builder for creating a AppDictItem entity.
func (c *AppDictItemClient) Create() *AppDictItemCreate {
	mutation := newAppDictItemMutation(c.config, OpCreate)
	return &AppDictItemCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppDictItem entities.
func (c *AppDictItemClient) CreateBulk(builders ...*AppDictItemCreate) *AppDictItemCreateBulk {
	return &AppDictItemCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppDictItemClient) MapCreateBulk(slice any, setFunc func(*AppDictItemCreate, int)) *AppDictItemCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppDictItemCreateBulk{err: fmt.Errorf("calling to AppDictItemClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppDictItemCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppDictItemCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppDictItem.
func (c *AppDictItemClient) Update() *AppDictItemUpdate {
	mutation := newAppDictItemMutation(c.config, OpUpdate)
	return &AppDictItemUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppDictItemClient) UpdateOne(adi *AppDictItem) *AppDictItemUpdateOne {
	mutation := newAppDictItemMutation(c.config, OpUpdateOne, withAppDictItem(adi))
	return &AppDictItemUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppDictItemClient) UpdateOneID(id int) *AppDictItemUpdateOne {
	mutation := newAppDictItemMutation(c.config, OpUpdateOne, withAppDictItemID(id))
	return &AppDictItemUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppDictItem.
func (c *AppDictItemClient) Delete() *AppDictItemDelete {
	mutation := newAppDictItemMutation(c.config, OpDelete)
	return &AppDictItemDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppDictItemClient) DeleteOne(adi *AppDictItem) *AppDictItemDeleteOne {
	return c.DeleteOneID(adi.ID)
}

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

// Query returns a query builder for AppDictItem.
func (c *AppDictItemClient) Query() *AppDictItemQuery {
	return &AppDictItemQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppDictItem},
		inters: c.Interceptors(),
	}
}

// Get returns a AppDictItem entity by its id.
func (c *AppDictItemClient) Get(ctx context.Context, id int) (*AppDictItem, error) {
	return c.Query().Where(appdictitem.ID(id)).Only(entcache.WithEntryKey(ctx, "AppDictItem", id))
}

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

// QueryDict queries the dict edge of a AppDictItem.
func (c *AppDictItemClient) QueryDict(adi *AppDictItem) *AppDictQuery {
	query := (&AppDictClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := adi.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appdictitem.Table, appdictitem.FieldID, id),
			sqlgraph.To(appdict.Table, appdict.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appdictitem.DictTable, appdictitem.DictColumn),
		)
		fromV = sqlgraph.Neighbors(adi.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrg queries the org edge of a AppDictItem.
func (c *AppDictItemClient) QueryOrg(adi *AppDictItem) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := adi.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appdictitem.Table, appdictitem.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, appdictitem.OrgTable, appdictitem.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(adi.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppDictItemClient) Hooks() []Hook {
	hooks := c.hooks.AppDictItem
	return append(hooks[:len(hooks):len(hooks)], appdictitem.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppDictItemClient) Interceptors() []Interceptor {
	return c.inters.AppDictItem
}

func (c *AppDictItemClient) mutate(ctx context.Context, m *AppDictItemMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppDictItemCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppDictItemUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppDictItemUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppDictItemDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppDictItem mutation op: %q", m.Op())
	}
}

// AppMenuClient is a client for the AppMenu schema.
type AppMenuClient struct {
	config
}

// NewAppMenuClient returns a client for the AppMenu from the given config.
func NewAppMenuClient(c config) *AppMenuClient {
	return &AppMenuClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `appmenu.Intercept(f(g(h())))`.
func (c *AppMenuClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppMenu = append(c.inters.AppMenu, interceptors...)
}

// Create returns a builder for creating a AppMenu entity.
func (c *AppMenuClient) Create() *AppMenuCreate {
	mutation := newAppMenuMutation(c.config, OpCreate)
	return &AppMenuCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppMenu entities.
func (c *AppMenuClient) CreateBulk(builders ...*AppMenuCreate) *AppMenuCreateBulk {
	return &AppMenuCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppMenuClient) MapCreateBulk(slice any, setFunc func(*AppMenuCreate, int)) *AppMenuCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppMenuCreateBulk{err: fmt.Errorf("calling to AppMenuClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppMenuCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppMenuCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppMenu.
func (c *AppMenuClient) Update() *AppMenuUpdate {
	mutation := newAppMenuMutation(c.config, OpUpdate)
	return &AppMenuUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppMenuClient) UpdateOne(am *AppMenu) *AppMenuUpdateOne {
	mutation := newAppMenuMutation(c.config, OpUpdateOne, withAppMenu(am))
	return &AppMenuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppMenuClient) UpdateOneID(id int) *AppMenuUpdateOne {
	mutation := newAppMenuMutation(c.config, OpUpdateOne, withAppMenuID(id))
	return &AppMenuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppMenu.
func (c *AppMenuClient) Delete() *AppMenuDelete {
	mutation := newAppMenuMutation(c.config, OpDelete)
	return &AppMenuDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppMenuClient) DeleteOne(am *AppMenu) *AppMenuDeleteOne {
	return c.DeleteOneID(am.ID)
}

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

// Query returns a query builder for AppMenu.
func (c *AppMenuClient) Query() *AppMenuQuery {
	return &AppMenuQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppMenu},
		inters: c.Interceptors(),
	}
}

// Get returns a AppMenu entity by its id.
func (c *AppMenuClient) Get(ctx context.Context, id int) (*AppMenu, error) {
	return c.Query().Where(appmenu.ID(id)).Only(entcache.WithEntryKey(ctx, "AppMenu", id))
}

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

// QueryApp queries the app edge of a AppMenu.
func (c *AppMenuClient) QueryApp(am *AppMenu) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := am.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appmenu.Table, appmenu.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appmenu.AppTable, appmenu.AppColumn),
		)
		fromV = sqlgraph.Neighbors(am.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryAction queries the action edge of a AppMenu.
func (c *AppMenuClient) QueryAction(am *AppMenu) *AppActionQuery {
	query := (&AppActionClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := am.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appmenu.Table, appmenu.FieldID, id),
			sqlgraph.To(appaction.Table, appaction.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appmenu.ActionTable, appmenu.ActionColumn),
		)
		fromV = sqlgraph.Neighbors(am.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppMenuClient) Hooks() []Hook {
	hooks := c.hooks.AppMenu
	return append(hooks[:len(hooks):len(hooks)], appmenu.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppMenuClient) Interceptors() []Interceptor {
	return c.inters.AppMenu
}

func (c *AppMenuClient) mutate(ctx context.Context, m *AppMenuMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppMenuCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppMenuUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppMenuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppMenuDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppMenu mutation op: %q", m.Op())
	}
}

// AppPolicyClient is a client for the AppPolicy schema.
type AppPolicyClient struct {
	config
}

// NewAppPolicyClient returns a client for the AppPolicy from the given config.
func NewAppPolicyClient(c config) *AppPolicyClient {
	return &AppPolicyClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `apppolicy.Intercept(f(g(h())))`.
func (c *AppPolicyClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppPolicy = append(c.inters.AppPolicy, interceptors...)
}

// Create returns a builder for creating a AppPolicy entity.
func (c *AppPolicyClient) Create() *AppPolicyCreate {
	mutation := newAppPolicyMutation(c.config, OpCreate)
	return &AppPolicyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppPolicy entities.
func (c *AppPolicyClient) CreateBulk(builders ...*AppPolicyCreate) *AppPolicyCreateBulk {
	return &AppPolicyCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppPolicyClient) MapCreateBulk(slice any, setFunc func(*AppPolicyCreate, int)) *AppPolicyCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppPolicyCreateBulk{err: fmt.Errorf("calling to AppPolicyClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppPolicyCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppPolicyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppPolicy.
func (c *AppPolicyClient) Update() *AppPolicyUpdate {
	mutation := newAppPolicyMutation(c.config, OpUpdate)
	return &AppPolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppPolicyClient) UpdateOne(ap *AppPolicy) *AppPolicyUpdateOne {
	mutation := newAppPolicyMutation(c.config, OpUpdateOne, withAppPolicy(ap))
	return &AppPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppPolicyClient) UpdateOneID(id int) *AppPolicyUpdateOne {
	mutation := newAppPolicyMutation(c.config, OpUpdateOne, withAppPolicyID(id))
	return &AppPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppPolicy.
func (c *AppPolicyClient) Delete() *AppPolicyDelete {
	mutation := newAppPolicyMutation(c.config, OpDelete)
	return &AppPolicyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppPolicyClient) DeleteOne(ap *AppPolicy) *AppPolicyDeleteOne {
	return c.DeleteOneID(ap.ID)
}

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

// Query returns a query builder for AppPolicy.
func (c *AppPolicyClient) Query() *AppPolicyQuery {
	return &AppPolicyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppPolicy},
		inters: c.Interceptors(),
	}
}

// Get returns a AppPolicy entity by its id.
func (c *AppPolicyClient) Get(ctx context.Context, id int) (*AppPolicy, error) {
	return c.Query().Where(apppolicy.ID(id)).Only(entcache.WithEntryKey(ctx, "AppPolicy", id))
}

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

// QueryApp queries the app edge of a AppPolicy.
func (c *AppPolicyClient) QueryApp(ap *AppPolicy) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ap.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(apppolicy.Table, apppolicy.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, apppolicy.AppTable, apppolicy.AppColumn),
		)
		fromV = sqlgraph.Neighbors(ap.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRoles queries the roles edge of a AppPolicy.
func (c *AppPolicyClient) QueryRoles(ap *AppPolicy) *AppRoleQuery {
	query := (&AppRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ap.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(apppolicy.Table, apppolicy.FieldID, id),
			sqlgraph.To(approle.Table, approle.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, apppolicy.RolesTable, apppolicy.RolesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(ap.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryAppRolePolicy queries the app_role_policy edge of a AppPolicy.
func (c *AppPolicyClient) QueryAppRolePolicy(ap *AppPolicy) *AppRolePolicyQuery {
	query := (&AppRolePolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ap.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(apppolicy.Table, apppolicy.FieldID, id),
			sqlgraph.To(approlepolicy.Table, approlepolicy.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, apppolicy.AppRolePolicyTable, apppolicy.AppRolePolicyColumn),
		)
		fromV = sqlgraph.Neighbors(ap.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppPolicyClient) Hooks() []Hook {
	hooks := c.hooks.AppPolicy
	return append(hooks[:len(hooks):len(hooks)], apppolicy.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppPolicyClient) Interceptors() []Interceptor {
	return c.inters.AppPolicy
}

func (c *AppPolicyClient) mutate(ctx context.Context, m *AppPolicyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppPolicyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppPolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppPolicyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppPolicy mutation op: %q", m.Op())
	}
}

// AppResClient is a client for the AppRes schema.
type AppResClient struct {
	config
}

// NewAppResClient returns a client for the AppRes from the given config.
func NewAppResClient(c config) *AppResClient {
	return &AppResClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `appres.Intercept(f(g(h())))`.
func (c *AppResClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppRes = append(c.inters.AppRes, interceptors...)
}

// Create returns a builder for creating a AppRes entity.
func (c *AppResClient) Create() *AppResCreate {
	mutation := newAppResMutation(c.config, OpCreate)
	return &AppResCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppRes entities.
func (c *AppResClient) CreateBulk(builders ...*AppResCreate) *AppResCreateBulk {
	return &AppResCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppResClient) MapCreateBulk(slice any, setFunc func(*AppResCreate, int)) *AppResCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppResCreateBulk{err: fmt.Errorf("calling to AppResClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppResCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppResCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppRes.
func (c *AppResClient) Update() *AppResUpdate {
	mutation := newAppResMutation(c.config, OpUpdate)
	return &AppResUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppResClient) UpdateOne(ar *AppRes) *AppResUpdateOne {
	mutation := newAppResMutation(c.config, OpUpdateOne, withAppRes(ar))
	return &AppResUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppResClient) UpdateOneID(id int) *AppResUpdateOne {
	mutation := newAppResMutation(c.config, OpUpdateOne, withAppResID(id))
	return &AppResUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppRes.
func (c *AppResClient) Delete() *AppResDelete {
	mutation := newAppResMutation(c.config, OpDelete)
	return &AppResDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppResClient) DeleteOne(ar *AppRes) *AppResDeleteOne {
	return c.DeleteOneID(ar.ID)
}

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

// Query returns a query builder for AppRes.
func (c *AppResClient) Query() *AppResQuery {
	return &AppResQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppRes},
		inters: c.Interceptors(),
	}
}

// Get returns a AppRes entity by its id.
func (c *AppResClient) Get(ctx context.Context, id int) (*AppRes, error) {
	return c.Query().Where(appres.ID(id)).Only(entcache.WithEntryKey(ctx, "AppRes", id))
}

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

// QueryApp queries the app edge of a AppRes.
func (c *AppResClient) QueryApp(ar *AppRes) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ar.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(appres.Table, appres.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, appres.AppTable, appres.AppColumn),
		)
		fromV = sqlgraph.Neighbors(ar.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppResClient) Hooks() []Hook {
	hooks := c.hooks.AppRes
	return append(hooks[:len(hooks):len(hooks)], appres.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppResClient) Interceptors() []Interceptor {
	return c.inters.AppRes
}

func (c *AppResClient) mutate(ctx context.Context, m *AppResMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppResCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppResUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppResUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppResDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppRes mutation op: %q", m.Op())
	}
}

// AppRoleClient is a client for the AppRole schema.
type AppRoleClient struct {
	config
}

// NewAppRoleClient returns a client for the AppRole from the given config.
func NewAppRoleClient(c config) *AppRoleClient {
	return &AppRoleClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `approle.Intercept(f(g(h())))`.
func (c *AppRoleClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppRole = append(c.inters.AppRole, interceptors...)
}

// Create returns a builder for creating a AppRole entity.
func (c *AppRoleClient) Create() *AppRoleCreate {
	mutation := newAppRoleMutation(c.config, OpCreate)
	return &AppRoleCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppRole entities.
func (c *AppRoleClient) CreateBulk(builders ...*AppRoleCreate) *AppRoleCreateBulk {
	return &AppRoleCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppRoleClient) MapCreateBulk(slice any, setFunc func(*AppRoleCreate, int)) *AppRoleCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppRoleCreateBulk{err: fmt.Errorf("calling to AppRoleClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppRoleCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppRoleCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppRole.
func (c *AppRoleClient) Update() *AppRoleUpdate {
	mutation := newAppRoleMutation(c.config, OpUpdate)
	return &AppRoleUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppRoleClient) UpdateOne(ar *AppRole) *AppRoleUpdateOne {
	mutation := newAppRoleMutation(c.config, OpUpdateOne, withAppRole(ar))
	return &AppRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppRoleClient) UpdateOneID(id int) *AppRoleUpdateOne {
	mutation := newAppRoleMutation(c.config, OpUpdateOne, withAppRoleID(id))
	return &AppRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppRole.
func (c *AppRoleClient) Delete() *AppRoleDelete {
	mutation := newAppRoleMutation(c.config, OpDelete)
	return &AppRoleDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppRoleClient) DeleteOne(ar *AppRole) *AppRoleDeleteOne {
	return c.DeleteOneID(ar.ID)
}

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

// Query returns a query builder for AppRole.
func (c *AppRoleClient) Query() *AppRoleQuery {
	return &AppRoleQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppRole},
		inters: c.Interceptors(),
	}
}

// Get returns a AppRole entity by its id.
func (c *AppRoleClient) Get(ctx context.Context, id int) (*AppRole, error) {
	return c.Query().Where(approle.ID(id)).Only(entcache.WithEntryKey(ctx, "AppRole", id))
}

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

// QueryApp queries the app edge of a AppRole.
func (c *AppRoleClient) QueryApp(ar *AppRole) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ar.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(approle.Table, approle.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, approle.AppTable, approle.AppColumn),
		)
		fromV = sqlgraph.Neighbors(ar.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPolicies queries the policies edge of a AppRole.
func (c *AppRoleClient) QueryPolicies(ar *AppRole) *AppPolicyQuery {
	query := (&AppPolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ar.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(approle.Table, approle.FieldID, id),
			sqlgraph.To(apppolicy.Table, apppolicy.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, approle.PoliciesTable, approle.PoliciesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(ar.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryAppRolePolicy queries the app_role_policy edge of a AppRole.
func (c *AppRoleClient) QueryAppRolePolicy(ar *AppRole) *AppRolePolicyQuery {
	query := (&AppRolePolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ar.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(approle.Table, approle.FieldID, id),
			sqlgraph.To(approlepolicy.Table, approlepolicy.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, approle.AppRolePolicyTable, approle.AppRolePolicyColumn),
		)
		fromV = sqlgraph.Neighbors(ar.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppRoleClient) Hooks() []Hook {
	hooks := c.hooks.AppRole
	return append(hooks[:len(hooks):len(hooks)], approle.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppRoleClient) Interceptors() []Interceptor {
	return c.inters.AppRole
}

func (c *AppRoleClient) mutate(ctx context.Context, m *AppRoleMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppRoleCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppRoleUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppRoleDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppRole mutation op: %q", m.Op())
	}
}

// AppRolePolicyClient is a client for the AppRolePolicy schema.
type AppRolePolicyClient struct {
	config
}

// NewAppRolePolicyClient returns a client for the AppRolePolicy from the given config.
func NewAppRolePolicyClient(c config) *AppRolePolicyClient {
	return &AppRolePolicyClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `approlepolicy.Intercept(f(g(h())))`.
func (c *AppRolePolicyClient) Intercept(interceptors ...Interceptor) {
	c.inters.AppRolePolicy = append(c.inters.AppRolePolicy, interceptors...)
}

// Create returns a builder for creating a AppRolePolicy entity.
func (c *AppRolePolicyClient) Create() *AppRolePolicyCreate {
	mutation := newAppRolePolicyMutation(c.config, OpCreate)
	return &AppRolePolicyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AppRolePolicy entities.
func (c *AppRolePolicyClient) CreateBulk(builders ...*AppRolePolicyCreate) *AppRolePolicyCreateBulk {
	return &AppRolePolicyCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *AppRolePolicyClient) MapCreateBulk(slice any, setFunc func(*AppRolePolicyCreate, int)) *AppRolePolicyCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &AppRolePolicyCreateBulk{err: fmt.Errorf("calling to AppRolePolicyClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*AppRolePolicyCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &AppRolePolicyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AppRolePolicy.
func (c *AppRolePolicyClient) Update() *AppRolePolicyUpdate {
	mutation := newAppRolePolicyMutation(c.config, OpUpdate)
	return &AppRolePolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AppRolePolicyClient) UpdateOne(arp *AppRolePolicy) *AppRolePolicyUpdateOne {
	mutation := newAppRolePolicyMutation(c.config, OpUpdateOne, withAppRolePolicy(arp))
	return &AppRolePolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AppRolePolicyClient) UpdateOneID(id int) *AppRolePolicyUpdateOne {
	mutation := newAppRolePolicyMutation(c.config, OpUpdateOne, withAppRolePolicyID(id))
	return &AppRolePolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AppRolePolicy.
func (c *AppRolePolicyClient) Delete() *AppRolePolicyDelete {
	mutation := newAppRolePolicyMutation(c.config, OpDelete)
	return &AppRolePolicyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AppRolePolicyClient) DeleteOne(arp *AppRolePolicy) *AppRolePolicyDeleteOne {
	return c.DeleteOneID(arp.ID)
}

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

// Query returns a query builder for AppRolePolicy.
func (c *AppRolePolicyClient) Query() *AppRolePolicyQuery {
	return &AppRolePolicyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAppRolePolicy},
		inters: c.Interceptors(),
	}
}

// Get returns a AppRolePolicy entity by its id.
func (c *AppRolePolicyClient) Get(ctx context.Context, id int) (*AppRolePolicy, error) {
	return c.Query().Where(approlepolicy.ID(id)).Only(entcache.WithEntryKey(ctx, "AppRolePolicy", id))
}

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

// QueryRole queries the role edge of a AppRolePolicy.
func (c *AppRolePolicyClient) QueryRole(arp *AppRolePolicy) *AppRoleQuery {
	query := (&AppRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := arp.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(approlepolicy.Table, approlepolicy.FieldID, id),
			sqlgraph.To(approle.Table, approle.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, approlepolicy.RoleTable, approlepolicy.RoleColumn),
		)
		fromV = sqlgraph.Neighbors(arp.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPolicy queries the policy edge of a AppRolePolicy.
func (c *AppRolePolicyClient) QueryPolicy(arp *AppRolePolicy) *AppPolicyQuery {
	query := (&AppPolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := arp.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(approlepolicy.Table, approlepolicy.FieldID, id),
			sqlgraph.To(apppolicy.Table, apppolicy.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, approlepolicy.PolicyTable, approlepolicy.PolicyColumn),
		)
		fromV = sqlgraph.Neighbors(arp.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *AppRolePolicyClient) Hooks() []Hook {
	hooks := c.hooks.AppRolePolicy
	return append(hooks[:len(hooks):len(hooks)], approlepolicy.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *AppRolePolicyClient) Interceptors() []Interceptor {
	return c.inters.AppRolePolicy
}

func (c *AppRolePolicyClient) mutate(ctx context.Context, m *AppRolePolicyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AppRolePolicyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AppRolePolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AppRolePolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AppRolePolicyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AppRolePolicy mutation op: %q", m.Op())
	}
}

// FileClient is a client for the File schema.
type FileClient struct {
	config
}

// NewFileClient returns a client for the File from the given config.
func NewFileClient(c config) *FileClient {
	return &FileClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `file.Intercept(f(g(h())))`.
func (c *FileClient) Intercept(interceptors ...Interceptor) {
	c.inters.File = append(c.inters.File, interceptors...)
}

// Create returns a builder for creating a File entity.
func (c *FileClient) Create() *FileCreate {
	mutation := newFileMutation(c.config, OpCreate)
	return &FileCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of File entities.
func (c *FileClient) CreateBulk(builders ...*FileCreate) *FileCreateBulk {
	return &FileCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *FileClient) MapCreateBulk(slice any, setFunc func(*FileCreate, int)) *FileCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &FileCreateBulk{err: fmt.Errorf("calling to FileClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*FileCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &FileCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for File.
func (c *FileClient) Update() *FileUpdate {
	mutation := newFileMutation(c.config, OpUpdate)
	return &FileUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FileClient) UpdateOne(f *File) *FileUpdateOne {
	mutation := newFileMutation(c.config, OpUpdateOne, withFile(f))
	return &FileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FileClient) UpdateOneID(id int) *FileUpdateOne {
	mutation := newFileMutation(c.config, OpUpdateOne, withFileID(id))
	return &FileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for File.
func (c *FileClient) Delete() *FileDelete {
	mutation := newFileMutation(c.config, OpDelete)
	return &FileDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FileClient) DeleteOne(f *File) *FileDeleteOne {
	return c.DeleteOneID(f.ID)
}

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

// Query returns a query builder for File.
func (c *FileClient) Query() *FileQuery {
	return &FileQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeFile},
		inters: c.Interceptors(),
	}
}

// Get returns a File entity by its id.
func (c *FileClient) Get(ctx context.Context, id int) (*File, error) {
	return c.Query().Where(file.ID(id)).Only(entcache.WithEntryKey(ctx, "File", id))
}

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

// QuerySource queries the source edge of a File.
func (c *FileClient) QuerySource(f *File) *FileSourceQuery {
	query := (&FileSourceClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := f.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(file.Table, file.FieldID, id),
			sqlgraph.To(filesource.Table, filesource.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, file.SourceTable, file.SourceColumn),
		)
		fromV = sqlgraph.Neighbors(f.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *FileClient) Hooks() []Hook {
	hooks := c.hooks.File
	return append(hooks[:len(hooks):len(hooks)], file.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *FileClient) Interceptors() []Interceptor {
	return c.inters.File
}

func (c *FileClient) mutate(ctx context.Context, m *FileMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&FileCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&FileUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&FileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&FileDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown File mutation op: %q", m.Op())
	}
}

// FileSourceClient is a client for the FileSource schema.
type FileSourceClient struct {
	config
}

// NewFileSourceClient returns a client for the FileSource from the given config.
func NewFileSourceClient(c config) *FileSourceClient {
	return &FileSourceClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `filesource.Intercept(f(g(h())))`.
func (c *FileSourceClient) Intercept(interceptors ...Interceptor) {
	c.inters.FileSource = append(c.inters.FileSource, interceptors...)
}

// Create returns a builder for creating a FileSource entity.
func (c *FileSourceClient) Create() *FileSourceCreate {
	mutation := newFileSourceMutation(c.config, OpCreate)
	return &FileSourceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of FileSource entities.
func (c *FileSourceClient) CreateBulk(builders ...*FileSourceCreate) *FileSourceCreateBulk {
	return &FileSourceCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *FileSourceClient) MapCreateBulk(slice any, setFunc func(*FileSourceCreate, int)) *FileSourceCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &FileSourceCreateBulk{err: fmt.Errorf("calling to FileSourceClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*FileSourceCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &FileSourceCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for FileSource.
func (c *FileSourceClient) Update() *FileSourceUpdate {
	mutation := newFileSourceMutation(c.config, OpUpdate)
	return &FileSourceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *FileSourceClient) UpdateOne(fs *FileSource) *FileSourceUpdateOne {
	mutation := newFileSourceMutation(c.config, OpUpdateOne, withFileSource(fs))
	return &FileSourceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *FileSourceClient) UpdateOneID(id int) *FileSourceUpdateOne {
	mutation := newFileSourceMutation(c.config, OpUpdateOne, withFileSourceID(id))
	return &FileSourceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for FileSource.
func (c *FileSourceClient) Delete() *FileSourceDelete {
	mutation := newFileSourceMutation(c.config, OpDelete)
	return &FileSourceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *FileSourceClient) DeleteOne(fs *FileSource) *FileSourceDeleteOne {
	return c.DeleteOneID(fs.ID)
}

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

// Query returns a query builder for FileSource.
func (c *FileSourceClient) Query() *FileSourceQuery {
	return &FileSourceQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeFileSource},
		inters: c.Interceptors(),
	}
}

// Get returns a FileSource entity by its id.
func (c *FileSourceClient) Get(ctx context.Context, id int) (*FileSource, error) {
	return c.Query().Where(filesource.ID(id)).Only(entcache.WithEntryKey(ctx, "FileSource", id))
}

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

// QueryFiles queries the files edge of a FileSource.
func (c *FileSourceClient) QueryFiles(fs *FileSource) *FileQuery {
	query := (&FileClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := fs.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(filesource.Table, filesource.FieldID, id),
			sqlgraph.To(file.Table, file.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, filesource.FilesTable, filesource.FilesColumn),
		)
		fromV = sqlgraph.Neighbors(fs.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *FileSourceClient) Hooks() []Hook {
	hooks := c.hooks.FileSource
	return append(hooks[:len(hooks):len(hooks)], filesource.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *FileSourceClient) Interceptors() []Interceptor {
	return c.inters.FileSource
}

func (c *FileSourceClient) mutate(ctx context.Context, m *FileSourceMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&FileSourceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&FileSourceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&FileSourceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&FileSourceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown FileSource mutation op: %q", m.Op())
	}
}

// OauthClientClient is a client for the OauthClient schema.
type OauthClientClient struct {
	config
}

// NewOauthClientClient returns a client for the OauthClient from the given config.
func NewOauthClientClient(c config) *OauthClientClient {
	return &OauthClientClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `oauthclient.Intercept(f(g(h())))`.
func (c *OauthClientClient) Intercept(interceptors ...Interceptor) {
	c.inters.OauthClient = append(c.inters.OauthClient, interceptors...)
}

// Create returns a builder for creating a OauthClient entity.
func (c *OauthClientClient) Create() *OauthClientCreate {
	mutation := newOauthClientMutation(c.config, OpCreate)
	return &OauthClientCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OauthClient entities.
func (c *OauthClientClient) CreateBulk(builders ...*OauthClientCreate) *OauthClientCreateBulk {
	return &OauthClientCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OauthClientClient) MapCreateBulk(slice any, setFunc func(*OauthClientCreate, int)) *OauthClientCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OauthClientCreateBulk{err: fmt.Errorf("calling to OauthClientClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OauthClientCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OauthClientCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OauthClient.
func (c *OauthClientClient) Update() *OauthClientUpdate {
	mutation := newOauthClientMutation(c.config, OpUpdate)
	return &OauthClientUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OauthClientClient) UpdateOne(oc *OauthClient) *OauthClientUpdateOne {
	mutation := newOauthClientMutation(c.config, OpUpdateOne, withOauthClient(oc))
	return &OauthClientUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OauthClientClient) UpdateOneID(id int) *OauthClientUpdateOne {
	mutation := newOauthClientMutation(c.config, OpUpdateOne, withOauthClientID(id))
	return &OauthClientUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OauthClient.
func (c *OauthClientClient) Delete() *OauthClientDelete {
	mutation := newOauthClientMutation(c.config, OpDelete)
	return &OauthClientDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OauthClientClient) DeleteOne(oc *OauthClient) *OauthClientDeleteOne {
	return c.DeleteOneID(oc.ID)
}

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

// Query returns a query builder for OauthClient.
func (c *OauthClientClient) Query() *OauthClientQuery {
	return &OauthClientQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOauthClient},
		inters: c.Interceptors(),
	}
}

// Get returns a OauthClient entity by its id.
func (c *OauthClientClient) Get(ctx context.Context, id int) (*OauthClient, error) {
	return c.Query().Where(oauthclient.ID(id)).Only(entcache.WithEntryKey(ctx, "OauthClient", id))
}

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

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

// Hooks returns the client hooks.
func (c *OauthClientClient) Hooks() []Hook {
	hooks := c.hooks.OauthClient
	return append(hooks[:len(hooks):len(hooks)], oauthclient.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OauthClientClient) Interceptors() []Interceptor {
	return c.inters.OauthClient
}

func (c *OauthClientClient) mutate(ctx context.Context, m *OauthClientMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OauthClientCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OauthClientUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OauthClientUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OauthClientDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OauthClient mutation op: %q", m.Op())
	}
}

// OrgClient is a client for the Org schema.
type OrgClient struct {
	config
}

// NewOrgClient returns a client for the Org from the given config.
func NewOrgClient(c config) *OrgClient {
	return &OrgClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `org.Intercept(f(g(h())))`.
func (c *OrgClient) Intercept(interceptors ...Interceptor) {
	c.inters.Org = append(c.inters.Org, interceptors...)
}

// Create returns a builder for creating a Org entity.
func (c *OrgClient) Create() *OrgCreate {
	mutation := newOrgMutation(c.config, OpCreate)
	return &OrgCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Org entities.
func (c *OrgClient) CreateBulk(builders ...*OrgCreate) *OrgCreateBulk {
	return &OrgCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgClient) MapCreateBulk(slice any, setFunc func(*OrgCreate, int)) *OrgCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgCreateBulk{err: fmt.Errorf("calling to OrgClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Org.
func (c *OrgClient) Update() *OrgUpdate {
	mutation := newOrgMutation(c.config, OpUpdate)
	return &OrgUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgClient) UpdateOne(o *Org) *OrgUpdateOne {
	mutation := newOrgMutation(c.config, OpUpdateOne, withOrg(o))
	return &OrgUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgClient) UpdateOneID(id int) *OrgUpdateOne {
	mutation := newOrgMutation(c.config, OpUpdateOne, withOrgID(id))
	return &OrgUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Org.
func (c *OrgClient) Delete() *OrgDelete {
	mutation := newOrgMutation(c.config, OpDelete)
	return &OrgDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgClient) DeleteOne(o *Org) *OrgDeleteOne {
	return c.DeleteOneID(o.ID)
}

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

// Query returns a query builder for Org.
func (c *OrgClient) Query() *OrgQuery {
	return &OrgQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrg},
		inters: c.Interceptors(),
	}
}

// Get returns a Org entity by its id.
func (c *OrgClient) Get(ctx context.Context, id int) (*Org, error) {
	return c.Query().Where(org.ID(id)).Only(entcache.WithEntryKey(ctx, "Org", id))
}

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

// QueryParent queries the parent edge of a Org.
func (c *OrgClient) QueryParent(o *Org) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, org.ParentTable, org.ParentColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChildren queries the children edge of a Org.
func (c *OrgClient) QueryChildren(o *Org) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, org.ChildrenTable, org.ChildrenColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOwner queries the owner edge of a Org.
func (c *OrgClient) QueryOwner(o *Org) *UserQuery {
	query := (&UserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, org.OwnerTable, org.OwnerColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryUsers queries the users edge of a Org.
func (c *OrgClient) QueryUsers(o *Org) *UserQuery {
	query := (&UserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(user.Table, user.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, org.UsersTable, org.UsersPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryRolesAndGroups queries the roles_and_groups edge of a Org.
func (c *OrgClient) QueryRolesAndGroups(o *Org) *OrgRoleQuery {
	query := (&OrgRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(orgrole.Table, orgrole.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, org.RolesAndGroupsTable, org.RolesAndGroupsColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPermissions queries the permissions edge of a Org.
func (c *OrgClient) QueryPermissions(o *Org) *PermissionQuery {
	query := (&PermissionClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(permission.Table, permission.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, org.PermissionsTable, org.PermissionsColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPolicies queries the policies edge of a Org.
func (c *OrgClient) QueryPolicies(o *Org) *OrgPolicyQuery {
	query := (&OrgPolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(orgpolicy.Table, orgpolicy.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, org.PoliciesTable, org.PoliciesColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryApps queries the apps edge of a Org.
func (c *OrgClient) QueryApps(o *Org) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, org.AppsTable, org.AppsPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgUser queries the org_user edge of a Org.
func (c *OrgClient) QueryOrgUser(o *Org) *OrgUserQuery {
	query := (&OrgUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(orguser.Table, orguser.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, org.OrgUserTable, org.OrgUserColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgApp queries the org_app edge of a Org.
func (c *OrgClient) QueryOrgApp(o *Org) *OrgAppQuery {
	query := (&OrgAppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(org.Table, org.FieldID, id),
			sqlgraph.To(orgapp.Table, orgapp.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, org.OrgAppTable, org.OrgAppColumn),
		)
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgClient) Hooks() []Hook {
	hooks := c.hooks.Org
	return append(hooks[:len(hooks):len(hooks)], org.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgClient) Interceptors() []Interceptor {
	inters := c.inters.Org
	return append(inters[:len(inters):len(inters)], org.Interceptors[:]...)
}

func (c *OrgClient) mutate(ctx context.Context, m *OrgMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Org mutation op: %q", m.Op())
	}
}

// OrgAppClient is a client for the OrgApp schema.
type OrgAppClient struct {
	config
}

// NewOrgAppClient returns a client for the OrgApp from the given config.
func NewOrgAppClient(c config) *OrgAppClient {
	return &OrgAppClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orgapp.Intercept(f(g(h())))`.
func (c *OrgAppClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgApp = append(c.inters.OrgApp, interceptors...)
}

// Create returns a builder for creating a OrgApp entity.
func (c *OrgAppClient) Create() *OrgAppCreate {
	mutation := newOrgAppMutation(c.config, OpCreate)
	return &OrgAppCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgApp entities.
func (c *OrgAppClient) CreateBulk(builders ...*OrgAppCreate) *OrgAppCreateBulk {
	return &OrgAppCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgAppClient) MapCreateBulk(slice any, setFunc func(*OrgAppCreate, int)) *OrgAppCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgAppCreateBulk{err: fmt.Errorf("calling to OrgAppClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgAppCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgAppCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgApp.
func (c *OrgAppClient) Update() *OrgAppUpdate {
	mutation := newOrgAppMutation(c.config, OpUpdate)
	return &OrgAppUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgAppClient) UpdateOne(oa *OrgApp) *OrgAppUpdateOne {
	mutation := newOrgAppMutation(c.config, OpUpdateOne, withOrgApp(oa))
	return &OrgAppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgAppClient) UpdateOneID(id int) *OrgAppUpdateOne {
	mutation := newOrgAppMutation(c.config, OpUpdateOne, withOrgAppID(id))
	return &OrgAppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgApp.
func (c *OrgAppClient) Delete() *OrgAppDelete {
	mutation := newOrgAppMutation(c.config, OpDelete)
	return &OrgAppDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgAppClient) DeleteOne(oa *OrgApp) *OrgAppDeleteOne {
	return c.DeleteOneID(oa.ID)
}

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

// Query returns a query builder for OrgApp.
func (c *OrgAppClient) Query() *OrgAppQuery {
	return &OrgAppQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgApp},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgApp entity by its id.
func (c *OrgAppClient) Get(ctx context.Context, id int) (*OrgApp, error) {
	return c.Query().Where(orgapp.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgApp", id))
}

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

// QueryApp queries the app edge of a OrgApp.
func (c *OrgAppClient) QueryApp(oa *OrgApp) *AppQuery {
	query := (&AppClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgapp.Table, orgapp.FieldID, id),
			sqlgraph.To(app.Table, app.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orgapp.AppTable, orgapp.AppColumn),
		)
		fromV = sqlgraph.Neighbors(oa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrg queries the org edge of a OrgApp.
func (c *OrgAppClient) QueryOrg(oa *OrgApp) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oa.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgapp.Table, orgapp.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orgapp.OrgTable, orgapp.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(oa.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgAppClient) Hooks() []Hook {
	hooks := c.hooks.OrgApp
	return append(hooks[:len(hooks):len(hooks)], orgapp.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgAppClient) Interceptors() []Interceptor {
	return c.inters.OrgApp
}

func (c *OrgAppClient) mutate(ctx context.Context, m *OrgAppMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgAppCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgAppUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgAppUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgAppDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgApp mutation op: %q", m.Op())
	}
}

// OrgPolicyClient is a client for the OrgPolicy schema.
type OrgPolicyClient struct {
	config
}

// NewOrgPolicyClient returns a client for the OrgPolicy from the given config.
func NewOrgPolicyClient(c config) *OrgPolicyClient {
	return &OrgPolicyClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orgpolicy.Intercept(f(g(h())))`.
func (c *OrgPolicyClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgPolicy = append(c.inters.OrgPolicy, interceptors...)
}

// Create returns a builder for creating a OrgPolicy entity.
func (c *OrgPolicyClient) Create() *OrgPolicyCreate {
	mutation := newOrgPolicyMutation(c.config, OpCreate)
	return &OrgPolicyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgPolicy entities.
func (c *OrgPolicyClient) CreateBulk(builders ...*OrgPolicyCreate) *OrgPolicyCreateBulk {
	return &OrgPolicyCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgPolicyClient) MapCreateBulk(slice any, setFunc func(*OrgPolicyCreate, int)) *OrgPolicyCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgPolicyCreateBulk{err: fmt.Errorf("calling to OrgPolicyClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgPolicyCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgPolicyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgPolicy.
func (c *OrgPolicyClient) Update() *OrgPolicyUpdate {
	mutation := newOrgPolicyMutation(c.config, OpUpdate)
	return &OrgPolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgPolicyClient) UpdateOne(op *OrgPolicy) *OrgPolicyUpdateOne {
	mutation := newOrgPolicyMutation(c.config, OpUpdateOne, withOrgPolicy(op))
	return &OrgPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgPolicyClient) UpdateOneID(id int) *OrgPolicyUpdateOne {
	mutation := newOrgPolicyMutation(c.config, OpUpdateOne, withOrgPolicyID(id))
	return &OrgPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgPolicy.
func (c *OrgPolicyClient) Delete() *OrgPolicyDelete {
	mutation := newOrgPolicyMutation(c.config, OpDelete)
	return &OrgPolicyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgPolicyClient) DeleteOne(op *OrgPolicy) *OrgPolicyDeleteOne {
	return c.DeleteOneID(op.ID)
}

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

// Query returns a query builder for OrgPolicy.
func (c *OrgPolicyClient) Query() *OrgPolicyQuery {
	return &OrgPolicyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgPolicy},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgPolicy entity by its id.
func (c *OrgPolicyClient) Get(ctx context.Context, id int) (*OrgPolicy, error) {
	return c.Query().Where(orgpolicy.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgPolicy", id))
}

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

// QueryOrg queries the org edge of a OrgPolicy.
func (c *OrgPolicyClient) QueryOrg(op *OrgPolicy) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := op.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgpolicy.Table, orgpolicy.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, orgpolicy.OrgTable, orgpolicy.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(op.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPermissions queries the permissions edge of a OrgPolicy.
func (c *OrgPolicyClient) QueryPermissions(op *OrgPolicy) *PermissionQuery {
	query := (&PermissionClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := op.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgpolicy.Table, orgpolicy.FieldID, id),
			sqlgraph.To(permission.Table, permission.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, orgpolicy.PermissionsTable, orgpolicy.PermissionsColumn),
		)
		fromV = sqlgraph.Neighbors(op.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgPolicyClient) Hooks() []Hook {
	hooks := c.hooks.OrgPolicy
	return append(hooks[:len(hooks):len(hooks)], orgpolicy.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgPolicyClient) Interceptors() []Interceptor {
	return c.inters.OrgPolicy
}

func (c *OrgPolicyClient) mutate(ctx context.Context, m *OrgPolicyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgPolicyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgPolicyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgPolicyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgPolicyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgPolicy mutation op: %q", m.Op())
	}
}

// OrgRoleClient is a client for the OrgRole schema.
type OrgRoleClient struct {
	config
}

// NewOrgRoleClient returns a client for the OrgRole from the given config.
func NewOrgRoleClient(c config) *OrgRoleClient {
	return &OrgRoleClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orgrole.Intercept(f(g(h())))`.
func (c *OrgRoleClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgRole = append(c.inters.OrgRole, interceptors...)
}

// Create returns a builder for creating a OrgRole entity.
func (c *OrgRoleClient) Create() *OrgRoleCreate {
	mutation := newOrgRoleMutation(c.config, OpCreate)
	return &OrgRoleCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgRole entities.
func (c *OrgRoleClient) CreateBulk(builders ...*OrgRoleCreate) *OrgRoleCreateBulk {
	return &OrgRoleCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgRoleClient) MapCreateBulk(slice any, setFunc func(*OrgRoleCreate, int)) *OrgRoleCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgRoleCreateBulk{err: fmt.Errorf("calling to OrgRoleClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgRoleCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgRoleCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgRole.
func (c *OrgRoleClient) Update() *OrgRoleUpdate {
	mutation := newOrgRoleMutation(c.config, OpUpdate)
	return &OrgRoleUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgRoleClient) UpdateOne(or *OrgRole) *OrgRoleUpdateOne {
	mutation := newOrgRoleMutation(c.config, OpUpdateOne, withOrgRole(or))
	return &OrgRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgRoleClient) UpdateOneID(id int) *OrgRoleUpdateOne {
	mutation := newOrgRoleMutation(c.config, OpUpdateOne, withOrgRoleID(id))
	return &OrgRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgRole.
func (c *OrgRoleClient) Delete() *OrgRoleDelete {
	mutation := newOrgRoleMutation(c.config, OpDelete)
	return &OrgRoleDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgRoleClient) DeleteOne(or *OrgRole) *OrgRoleDeleteOne {
	return c.DeleteOneID(or.ID)
}

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

// Query returns a query builder for OrgRole.
func (c *OrgRoleClient) Query() *OrgRoleQuery {
	return &OrgRoleQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgRole},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgRole entity by its id.
func (c *OrgRoleClient) Get(ctx context.Context, id int) (*OrgRole, error) {
	return c.Query().Where(orgrole.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgRole", id))
}

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

// QueryOrg queries the org edge of a OrgRole.
func (c *OrgRoleClient) QueryOrg(or *OrgRole) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := or.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgrole.Table, orgrole.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, orgrole.OrgTable, orgrole.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(or.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgUsers queries the org_users edge of a OrgRole.
func (c *OrgRoleClient) QueryOrgUsers(or *OrgRole) *OrgUserQuery {
	query := (&OrgUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := or.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgrole.Table, orgrole.FieldID, id),
			sqlgraph.To(orguser.Table, orguser.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, orgrole.OrgUsersTable, orgrole.OrgUsersPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(or.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgRoleUser queries the org_role_user edge of a OrgRole.
func (c *OrgRoleClient) QueryOrgRoleUser(or *OrgRole) *OrgRoleUserQuery {
	query := (&OrgRoleUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := or.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgrole.Table, orgrole.FieldID, id),
			sqlgraph.To(orgroleuser.Table, orgroleuser.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, orgrole.OrgRoleUserTable, orgrole.OrgRoleUserColumn),
		)
		fromV = sqlgraph.Neighbors(or.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgRoleClient) Hooks() []Hook {
	hooks := c.hooks.OrgRole
	return append(hooks[:len(hooks):len(hooks)], orgrole.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgRoleClient) Interceptors() []Interceptor {
	return c.inters.OrgRole
}

func (c *OrgRoleClient) mutate(ctx context.Context, m *OrgRoleMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgRoleCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgRoleUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgRoleUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgRoleDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgRole mutation op: %q", m.Op())
	}
}

// OrgRoleUserClient is a client for the OrgRoleUser schema.
type OrgRoleUserClient struct {
	config
}

// NewOrgRoleUserClient returns a client for the OrgRoleUser from the given config.
func NewOrgRoleUserClient(c config) *OrgRoleUserClient {
	return &OrgRoleUserClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orgroleuser.Intercept(f(g(h())))`.
func (c *OrgRoleUserClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgRoleUser = append(c.inters.OrgRoleUser, interceptors...)
}

// Create returns a builder for creating a OrgRoleUser entity.
func (c *OrgRoleUserClient) Create() *OrgRoleUserCreate {
	mutation := newOrgRoleUserMutation(c.config, OpCreate)
	return &OrgRoleUserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgRoleUser entities.
func (c *OrgRoleUserClient) CreateBulk(builders ...*OrgRoleUserCreate) *OrgRoleUserCreateBulk {
	return &OrgRoleUserCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgRoleUserClient) MapCreateBulk(slice any, setFunc func(*OrgRoleUserCreate, int)) *OrgRoleUserCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgRoleUserCreateBulk{err: fmt.Errorf("calling to OrgRoleUserClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgRoleUserCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgRoleUserCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgRoleUser.
func (c *OrgRoleUserClient) Update() *OrgRoleUserUpdate {
	mutation := newOrgRoleUserMutation(c.config, OpUpdate)
	return &OrgRoleUserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgRoleUserClient) UpdateOne(oru *OrgRoleUser) *OrgRoleUserUpdateOne {
	mutation := newOrgRoleUserMutation(c.config, OpUpdateOne, withOrgRoleUser(oru))
	return &OrgRoleUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgRoleUserClient) UpdateOneID(id int) *OrgRoleUserUpdateOne {
	mutation := newOrgRoleUserMutation(c.config, OpUpdateOne, withOrgRoleUserID(id))
	return &OrgRoleUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgRoleUser.
func (c *OrgRoleUserClient) Delete() *OrgRoleUserDelete {
	mutation := newOrgRoleUserMutation(c.config, OpDelete)
	return &OrgRoleUserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgRoleUserClient) DeleteOne(oru *OrgRoleUser) *OrgRoleUserDeleteOne {
	return c.DeleteOneID(oru.ID)
}

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

// Query returns a query builder for OrgRoleUser.
func (c *OrgRoleUserClient) Query() *OrgRoleUserQuery {
	return &OrgRoleUserQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgRoleUser},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgRoleUser entity by its id.
func (c *OrgRoleUserClient) Get(ctx context.Context, id int) (*OrgRoleUser, error) {
	return c.Query().Where(orgroleuser.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgRoleUser", id))
}

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

// QueryOrgRole queries the org_role edge of a OrgRoleUser.
func (c *OrgRoleUserClient) QueryOrgRole(oru *OrgRoleUser) *OrgRoleQuery {
	query := (&OrgRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oru.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgroleuser.Table, orgroleuser.FieldID, id),
			sqlgraph.To(orgrole.Table, orgrole.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orgroleuser.OrgRoleTable, orgroleuser.OrgRoleColumn),
		)
		fromV = sqlgraph.Neighbors(oru.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgUser queries the org_user edge of a OrgRoleUser.
func (c *OrgRoleUserClient) QueryOrgUser(oru *OrgRoleUser) *OrgUserQuery {
	query := (&OrgUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oru.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgroleuser.Table, orgroleuser.FieldID, id),
			sqlgraph.To(orguser.Table, orguser.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orgroleuser.OrgUserTable, orgroleuser.OrgUserColumn),
		)
		fromV = sqlgraph.Neighbors(oru.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// QueryOrg queries the org edge of a OrgRoleUser.
func (c *OrgRoleUserClient) QueryOrg(oru *OrgRoleUser) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oru.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orgroleuser.Table, orgroleuser.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orgroleuser.OrgTable, orgroleuser.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(oru.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgRoleUserClient) Hooks() []Hook {
	hooks := c.hooks.OrgRoleUser
	return append(hooks[:len(hooks):len(hooks)], orgroleuser.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgRoleUserClient) Interceptors() []Interceptor {
	return c.inters.OrgRoleUser
}

func (c *OrgRoleUserClient) mutate(ctx context.Context, m *OrgRoleUserMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgRoleUserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgRoleUserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgRoleUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgRoleUserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgRoleUser mutation op: %q", m.Op())
	}
}

// OrgUserClient is a client for the OrgUser schema.
type OrgUserClient struct {
	config
}

// NewOrgUserClient returns a client for the OrgUser from the given config.
func NewOrgUserClient(c config) *OrgUserClient {
	return &OrgUserClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orguser.Intercept(f(g(h())))`.
func (c *OrgUserClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgUser = append(c.inters.OrgUser, interceptors...)
}

// Create returns a builder for creating a OrgUser entity.
func (c *OrgUserClient) Create() *OrgUserCreate {
	mutation := newOrgUserMutation(c.config, OpCreate)
	return &OrgUserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgUser entities.
func (c *OrgUserClient) CreateBulk(builders ...*OrgUserCreate) *OrgUserCreateBulk {
	return &OrgUserCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgUserClient) MapCreateBulk(slice any, setFunc func(*OrgUserCreate, int)) *OrgUserCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgUserCreateBulk{err: fmt.Errorf("calling to OrgUserClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgUserCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgUserCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgUser.
func (c *OrgUserClient) Update() *OrgUserUpdate {
	mutation := newOrgUserMutation(c.config, OpUpdate)
	return &OrgUserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgUserClient) UpdateOne(ou *OrgUser) *OrgUserUpdateOne {
	mutation := newOrgUserMutation(c.config, OpUpdateOne, withOrgUser(ou))
	return &OrgUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgUserClient) UpdateOneID(id int) *OrgUserUpdateOne {
	mutation := newOrgUserMutation(c.config, OpUpdateOne, withOrgUserID(id))
	return &OrgUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgUser.
func (c *OrgUserClient) Delete() *OrgUserDelete {
	mutation := newOrgUserMutation(c.config, OpDelete)
	return &OrgUserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgUserClient) DeleteOne(ou *OrgUser) *OrgUserDeleteOne {
	return c.DeleteOneID(ou.ID)
}

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

// Query returns a query builder for OrgUser.
func (c *OrgUserClient) Query() *OrgUserQuery {
	return &OrgUserQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgUser},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgUser entity by its id.
func (c *OrgUserClient) Get(ctx context.Context, id int) (*OrgUser, error) {
	return c.Query().Where(orguser.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgUser", id))
}

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

// QueryOrg queries the org edge of a OrgUser.
func (c *OrgUserClient) QueryOrg(ou *OrgUser) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ou.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orguser.Table, orguser.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orguser.OrgTable, orguser.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(ou.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// QueryOrgRoles queries the org_roles edge of a OrgUser.
func (c *OrgUserClient) QueryOrgRoles(ou *OrgUser) *OrgRoleQuery {
	query := (&OrgRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ou.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orguser.Table, orguser.FieldID, id),
			sqlgraph.To(orgrole.Table, orgrole.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, orguser.OrgRolesTable, orguser.OrgRolesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(ou.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgRoleUser queries the org_role_user edge of a OrgUser.
func (c *OrgUserClient) QueryOrgRoleUser(ou *OrgUser) *OrgRoleUserQuery {
	query := (&OrgRoleUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ou.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orguser.Table, orguser.FieldID, id),
			sqlgraph.To(orgroleuser.Table, orgroleuser.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, orguser.OrgRoleUserTable, orguser.OrgRoleUserColumn),
		)
		fromV = sqlgraph.Neighbors(ou.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgUserClient) Hooks() []Hook {
	hooks := c.hooks.OrgUser
	return append(hooks[:len(hooks):len(hooks)], orguser.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgUserClient) Interceptors() []Interceptor {
	return c.inters.OrgUser
}

func (c *OrgUserClient) mutate(ctx context.Context, m *OrgUserMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgUserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgUserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgUserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgUser mutation op: %q", m.Op())
	}
}

// OrgUserPreferenceClient is a client for the OrgUserPreference schema.
type OrgUserPreferenceClient struct {
	config
}

// NewOrgUserPreferenceClient returns a client for the OrgUserPreference from the given config.
func NewOrgUserPreferenceClient(c config) *OrgUserPreferenceClient {
	return &OrgUserPreferenceClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `orguserpreference.Intercept(f(g(h())))`.
func (c *OrgUserPreferenceClient) Intercept(interceptors ...Interceptor) {
	c.inters.OrgUserPreference = append(c.inters.OrgUserPreference, interceptors...)
}

// Create returns a builder for creating a OrgUserPreference entity.
func (c *OrgUserPreferenceClient) Create() *OrgUserPreferenceCreate {
	mutation := newOrgUserPreferenceMutation(c.config, OpCreate)
	return &OrgUserPreferenceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrgUserPreference entities.
func (c *OrgUserPreferenceClient) CreateBulk(builders ...*OrgUserPreferenceCreate) *OrgUserPreferenceCreateBulk {
	return &OrgUserPreferenceCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *OrgUserPreferenceClient) MapCreateBulk(slice any, setFunc func(*OrgUserPreferenceCreate, int)) *OrgUserPreferenceCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrgUserPreferenceCreateBulk{err: fmt.Errorf("calling to OrgUserPreferenceClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrgUserPreferenceCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrgUserPreferenceCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrgUserPreference.
func (c *OrgUserPreferenceClient) Update() *OrgUserPreferenceUpdate {
	mutation := newOrgUserPreferenceMutation(c.config, OpUpdate)
	return &OrgUserPreferenceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrgUserPreferenceClient) UpdateOne(oup *OrgUserPreference) *OrgUserPreferenceUpdateOne {
	mutation := newOrgUserPreferenceMutation(c.config, OpUpdateOne, withOrgUserPreference(oup))
	return &OrgUserPreferenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrgUserPreferenceClient) UpdateOneID(id int) *OrgUserPreferenceUpdateOne {
	mutation := newOrgUserPreferenceMutation(c.config, OpUpdateOne, withOrgUserPreferenceID(id))
	return &OrgUserPreferenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrgUserPreference.
func (c *OrgUserPreferenceClient) Delete() *OrgUserPreferenceDelete {
	mutation := newOrgUserPreferenceMutation(c.config, OpDelete)
	return &OrgUserPreferenceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrgUserPreferenceClient) DeleteOne(oup *OrgUserPreference) *OrgUserPreferenceDeleteOne {
	return c.DeleteOneID(oup.ID)
}

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

// Query returns a query builder for OrgUserPreference.
func (c *OrgUserPreferenceClient) Query() *OrgUserPreferenceQuery {
	return &OrgUserPreferenceQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrgUserPreference},
		inters: c.Interceptors(),
	}
}

// Get returns a OrgUserPreference entity by its id.
func (c *OrgUserPreferenceClient) Get(ctx context.Context, id int) (*OrgUserPreference, error) {
	return c.Query().Where(orguserpreference.ID(id)).Only(entcache.WithEntryKey(ctx, "OrgUserPreference", id))
}

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

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

// QueryOrg queries the org edge of a OrgUserPreference.
func (c *OrgUserPreferenceClient) QueryOrg(oup *OrgUserPreference) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := oup.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(orguserpreference.Table, orguserpreference.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, orguserpreference.OrgTable, orguserpreference.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(oup.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrgUserPreferenceClient) Hooks() []Hook {
	hooks := c.hooks.OrgUserPreference
	return append(hooks[:len(hooks):len(hooks)], orguserpreference.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *OrgUserPreferenceClient) Interceptors() []Interceptor {
	return c.inters.OrgUserPreference
}

func (c *OrgUserPreferenceClient) mutate(ctx context.Context, m *OrgUserPreferenceMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrgUserPreferenceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrgUserPreferenceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrgUserPreferenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrgUserPreferenceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown OrgUserPreference mutation op: %q", m.Op())
	}
}

// PermissionClient is a client for the Permission schema.
type PermissionClient struct {
	config
}

// NewPermissionClient returns a client for the Permission from the given config.
func NewPermissionClient(c config) *PermissionClient {
	return &PermissionClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `permission.Intercept(f(g(h())))`.
func (c *PermissionClient) Intercept(interceptors ...Interceptor) {
	c.inters.Permission = append(c.inters.Permission, interceptors...)
}

// Create returns a builder for creating a Permission entity.
func (c *PermissionClient) Create() *PermissionCreate {
	mutation := newPermissionMutation(c.config, OpCreate)
	return &PermissionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Permission entities.
func (c *PermissionClient) CreateBulk(builders ...*PermissionCreate) *PermissionCreateBulk {
	return &PermissionCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *PermissionClient) MapCreateBulk(slice any, setFunc func(*PermissionCreate, int)) *PermissionCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &PermissionCreateBulk{err: fmt.Errorf("calling to PermissionClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*PermissionCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &PermissionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Permission.
func (c *PermissionClient) Update() *PermissionUpdate {
	mutation := newPermissionMutation(c.config, OpUpdate)
	return &PermissionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PermissionClient) UpdateOne(pe *Permission) *PermissionUpdateOne {
	mutation := newPermissionMutation(c.config, OpUpdateOne, withPermission(pe))
	return &PermissionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PermissionClient) UpdateOneID(id int) *PermissionUpdateOne {
	mutation := newPermissionMutation(c.config, OpUpdateOne, withPermissionID(id))
	return &PermissionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Permission.
func (c *PermissionClient) Delete() *PermissionDelete {
	mutation := newPermissionMutation(c.config, OpDelete)
	return &PermissionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *PermissionClient) DeleteOne(pe *Permission) *PermissionDeleteOne {
	return c.DeleteOneID(pe.ID)
}

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

// Query returns a query builder for Permission.
func (c *PermissionClient) Query() *PermissionQuery {
	return &PermissionQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypePermission},
		inters: c.Interceptors(),
	}
}

// Get returns a Permission entity by its id.
func (c *PermissionClient) Get(ctx context.Context, id int) (*Permission, error) {
	return c.Query().Where(permission.ID(id)).Only(entcache.WithEntryKey(ctx, "Permission", id))
}

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

// QueryOrg queries the org edge of a Permission.
func (c *PermissionClient) QueryOrg(pe *Permission) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pe.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(permission.Table, permission.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, permission.OrgTable, permission.OrgColumn),
		)
		fromV = sqlgraph.Neighbors(pe.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// QueryRole queries the role edge of a Permission.
func (c *PermissionClient) QueryRole(pe *Permission) *OrgRoleQuery {
	query := (&OrgRoleClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pe.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(permission.Table, permission.FieldID, id),
			sqlgraph.To(orgrole.Table, orgrole.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, false, permission.RoleTable, permission.RoleColumn),
		)
		fromV = sqlgraph.Neighbors(pe.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgPolicy queries the org_policy edge of a Permission.
func (c *PermissionClient) QueryOrgPolicy(pe *Permission) *OrgPolicyQuery {
	query := (&OrgPolicyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pe.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(permission.Table, permission.FieldID, id),
			sqlgraph.To(orgpolicy.Table, orgpolicy.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, permission.OrgPolicyTable, permission.OrgPolicyColumn),
		)
		fromV = sqlgraph.Neighbors(pe.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *PermissionClient) Hooks() []Hook {
	hooks := c.hooks.Permission
	return append(hooks[:len(hooks):len(hooks)], permission.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *PermissionClient) Interceptors() []Interceptor {
	return c.inters.Permission
}

func (c *PermissionClient) mutate(ctx context.Context, m *PermissionMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&PermissionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&PermissionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&PermissionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&PermissionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Permission mutation op: %q", m.Op())
	}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`.
func (c *UserClient) Intercept(interceptors ...Interceptor) {
	c.inters.User = append(c.inters.User, interceptors...)
}

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

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

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserCreateBulk{config: c.config, builders: builders}
}

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

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

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

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

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

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

// Query returns a query builder for User.
func (c *UserClient) Query() *UserQuery {
	return &UserQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUser},
		inters: c.Interceptors(),
	}
}

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

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

// QueryIdentities queries the identities edge of a User.
func (c *UserClient) QueryIdentities(u *User) *UserIdentityQuery {
	query := (&UserIdentityClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(useridentity.Table, useridentity.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.IdentitiesTable, user.IdentitiesColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLoginProfile queries the login_profile edge of a User.
func (c *UserClient) QueryLoginProfile(u *User) *UserLoginProfileQuery {
	query := (&UserLoginProfileClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(userloginprofile.Table, userloginprofile.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, user.LoginProfileTable, user.LoginProfileColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPasswords queries the passwords edge of a User.
func (c *UserClient) QueryPasswords(u *User) *UserPasswordQuery {
	query := (&UserPasswordClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(userpassword.Table, userpassword.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.PasswordsTable, user.PasswordsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDevices queries the devices edge of a User.
func (c *UserClient) QueryDevices(u *User) *UserDeviceQuery {
	query := (&UserDeviceClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(userdevice.Table, userdevice.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.DevicesTable, user.DevicesColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgs queries the orgs edge of a User.
func (c *UserClient) QueryOrgs(u *User) *OrgQuery {
	query := (&OrgClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(org.Table, org.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, user.OrgsTable, user.OrgsPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPermissions queries the permissions edge of a User.
func (c *UserClient) QueryPermissions(u *User) *PermissionQuery {
	query := (&PermissionClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(permission.Table, permission.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, user.PermissionsTable, user.PermissionsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOauthClients queries the oauth_clients edge of a User.
func (c *UserClient) QueryOauthClients(u *User) *OauthClientQuery {
	query := (&OauthClientClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(oauthclient.Table, oauthclient.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.OauthClientsTable, user.OauthClientsColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOrgUser queries the org_user edge of a User.
func (c *UserClient) QueryOrgUser(u *User) *OrgUserQuery {
	query := (&OrgUserClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := u.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(user.Table, user.FieldID, id),
			sqlgraph.To(orguser.Table, orguser.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, true, user.OrgUserTable, user.OrgUserColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// Interceptors returns the client interceptors.
func (c *UserClient) Interceptors() []Interceptor {
	inters := c.inters.User
	return append(inters[:len(inters):len(inters)], user.Interceptors[:]...)
}

func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown User mutation op: %q", m.Op())
	}
}

// UserDeviceClient is a client for the UserDevice schema.
type UserDeviceClient struct {
	config
}

// NewUserDeviceClient returns a client for the UserDevice from the given config.
func NewUserDeviceClient(c config) *UserDeviceClient {
	return &UserDeviceClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `userdevice.Intercept(f(g(h())))`.
func (c *UserDeviceClient) Intercept(interceptors ...Interceptor) {
	c.inters.UserDevice = append(c.inters.UserDevice, interceptors...)
}

// Create returns a builder for creating a UserDevice entity.
func (c *UserDeviceClient) Create() *UserDeviceCreate {
	mutation := newUserDeviceMutation(c.config, OpCreate)
	return &UserDeviceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of UserDevice entities.
func (c *UserDeviceClient) CreateBulk(builders ...*UserDeviceCreate) *UserDeviceCreateBulk {
	return &UserDeviceCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *UserDeviceClient) MapCreateBulk(slice any, setFunc func(*UserDeviceCreate, int)) *UserDeviceCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserDeviceCreateBulk{err: fmt.Errorf("calling to UserDeviceClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserDeviceCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserDeviceCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for UserDevice.
func (c *UserDeviceClient) Update() *UserDeviceUpdate {
	mutation := newUserDeviceMutation(c.config, OpUpdate)
	return &UserDeviceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserDeviceClient) UpdateOne(ud *UserDevice) *UserDeviceUpdateOne {
	mutation := newUserDeviceMutation(c.config, OpUpdateOne, withUserDevice(ud))
	return &UserDeviceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserDeviceClient) UpdateOneID(id int) *UserDeviceUpdateOne {
	mutation := newUserDeviceMutation(c.config, OpUpdateOne, withUserDeviceID(id))
	return &UserDeviceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for UserDevice.
func (c *UserDeviceClient) Delete() *UserDeviceDelete {
	mutation := newUserDeviceMutation(c.config, OpDelete)
	return &UserDeviceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserDeviceClient) DeleteOne(ud *UserDevice) *UserDeviceDeleteOne {
	return c.DeleteOneID(ud.ID)
}

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

// Query returns a query builder for UserDevice.
func (c *UserDeviceClient) Query() *UserDeviceQuery {
	return &UserDeviceQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUserDevice},
		inters: c.Interceptors(),
	}
}

// Get returns a UserDevice entity by its id.
func (c *UserDeviceClient) Get(ctx context.Context, id int) (*UserDevice, error) {
	return c.Query().Where(userdevice.ID(id)).Only(entcache.WithEntryKey(ctx, "UserDevice", id))
}

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

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

// Hooks returns the client hooks.
func (c *UserDeviceClient) Hooks() []Hook {
	hooks := c.hooks.UserDevice
	return append(hooks[:len(hooks):len(hooks)], userdevice.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *UserDeviceClient) Interceptors() []Interceptor {
	return c.inters.UserDevice
}

func (c *UserDeviceClient) mutate(ctx context.Context, m *UserDeviceMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserDeviceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserDeviceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserDeviceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserDeviceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown UserDevice mutation op: %q", m.Op())
	}
}

// UserIdentityClient is a client for the UserIdentity schema.
type UserIdentityClient struct {
	config
}

// NewUserIdentityClient returns a client for the UserIdentity from the given config.
func NewUserIdentityClient(c config) *UserIdentityClient {
	return &UserIdentityClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `useridentity.Intercept(f(g(h())))`.
func (c *UserIdentityClient) Intercept(interceptors ...Interceptor) {
	c.inters.UserIdentity = append(c.inters.UserIdentity, interceptors...)
}

// Create returns a builder for creating a UserIdentity entity.
func (c *UserIdentityClient) Create() *UserIdentityCreate {
	mutation := newUserIdentityMutation(c.config, OpCreate)
	return &UserIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of UserIdentity entities.
func (c *UserIdentityClient) CreateBulk(builders ...*UserIdentityCreate) *UserIdentityCreateBulk {
	return &UserIdentityCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *UserIdentityClient) MapCreateBulk(slice any, setFunc func(*UserIdentityCreate, int)) *UserIdentityCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserIdentityCreateBulk{err: fmt.Errorf("calling to UserIdentityClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserIdentityCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserIdentityCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for UserIdentity.
func (c *UserIdentityClient) Update() *UserIdentityUpdate {
	mutation := newUserIdentityMutation(c.config, OpUpdate)
	return &UserIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserIdentityClient) UpdateOne(ui *UserIdentity) *UserIdentityUpdateOne {
	mutation := newUserIdentityMutation(c.config, OpUpdateOne, withUserIdentity(ui))
	return &UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserIdentityClient) UpdateOneID(id int) *UserIdentityUpdateOne {
	mutation := newUserIdentityMutation(c.config, OpUpdateOne, withUserIdentityID(id))
	return &UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for UserIdentity.
func (c *UserIdentityClient) Delete() *UserIdentityDelete {
	mutation := newUserIdentityMutation(c.config, OpDelete)
	return &UserIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserIdentityClient) DeleteOne(ui *UserIdentity) *UserIdentityDeleteOne {
	return c.DeleteOneID(ui.ID)
}

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

// Query returns a query builder for UserIdentity.
func (c *UserIdentityClient) Query() *UserIdentityQuery {
	return &UserIdentityQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUserIdentity},
		inters: c.Interceptors(),
	}
}

// Get returns a UserIdentity entity by its id.
func (c *UserIdentityClient) Get(ctx context.Context, id int) (*UserIdentity, error) {
	return c.Query().Where(useridentity.ID(id)).Only(entcache.WithEntryKey(ctx, "UserIdentity", id))
}

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

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

// Hooks returns the client hooks.
func (c *UserIdentityClient) Hooks() []Hook {
	hooks := c.hooks.UserIdentity
	return append(hooks[:len(hooks):len(hooks)], useridentity.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *UserIdentityClient) Interceptors() []Interceptor {
	return c.inters.UserIdentity
}

func (c *UserIdentityClient) mutate(ctx context.Context, m *UserIdentityMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown UserIdentity mutation op: %q", m.Op())
	}
}

// UserLoginProfileClient is a client for the UserLoginProfile schema.
type UserLoginProfileClient struct {
	config
}

// NewUserLoginProfileClient returns a client for the UserLoginProfile from the given config.
func NewUserLoginProfileClient(c config) *UserLoginProfileClient {
	return &UserLoginProfileClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `userloginprofile.Intercept(f(g(h())))`.
func (c *UserLoginProfileClient) Intercept(interceptors ...Interceptor) {
	c.inters.UserLoginProfile = append(c.inters.UserLoginProfile, interceptors...)
}

// Create returns a builder for creating a UserLoginProfile entity.
func (c *UserLoginProfileClient) Create() *UserLoginProfileCreate {
	mutation := newUserLoginProfileMutation(c.config, OpCreate)
	return &UserLoginProfileCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of UserLoginProfile entities.
func (c *UserLoginProfileClient) CreateBulk(builders ...*UserLoginProfileCreate) *UserLoginProfileCreateBulk {
	return &UserLoginProfileCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *UserLoginProfileClient) MapCreateBulk(slice any, setFunc func(*UserLoginProfileCreate, int)) *UserLoginProfileCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserLoginProfileCreateBulk{err: fmt.Errorf("calling to UserLoginProfileClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserLoginProfileCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserLoginProfileCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for UserLoginProfile.
func (c *UserLoginProfileClient) Update() *UserLoginProfileUpdate {
	mutation := newUserLoginProfileMutation(c.config, OpUpdate)
	return &UserLoginProfileUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserLoginProfileClient) UpdateOne(ulp *UserLoginProfile) *UserLoginProfileUpdateOne {
	mutation := newUserLoginProfileMutation(c.config, OpUpdateOne, withUserLoginProfile(ulp))
	return &UserLoginProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserLoginProfileClient) UpdateOneID(id int) *UserLoginProfileUpdateOne {
	mutation := newUserLoginProfileMutation(c.config, OpUpdateOne, withUserLoginProfileID(id))
	return &UserLoginProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for UserLoginProfile.
func (c *UserLoginProfileClient) Delete() *UserLoginProfileDelete {
	mutation := newUserLoginProfileMutation(c.config, OpDelete)
	return &UserLoginProfileDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserLoginProfileClient) DeleteOne(ulp *UserLoginProfile) *UserLoginProfileDeleteOne {
	return c.DeleteOneID(ulp.ID)
}

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

// Query returns a query builder for UserLoginProfile.
func (c *UserLoginProfileClient) Query() *UserLoginProfileQuery {
	return &UserLoginProfileQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUserLoginProfile},
		inters: c.Interceptors(),
	}
}

// Get returns a UserLoginProfile entity by its id.
func (c *UserLoginProfileClient) Get(ctx context.Context, id int) (*UserLoginProfile, error) {
	return c.Query().Where(userloginprofile.ID(id)).Only(entcache.WithEntryKey(ctx, "UserLoginProfile", id))
}

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

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

// Hooks returns the client hooks.
func (c *UserLoginProfileClient) Hooks() []Hook {
	hooks := c.hooks.UserLoginProfile
	return append(hooks[:len(hooks):len(hooks)], userloginprofile.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *UserLoginProfileClient) Interceptors() []Interceptor {
	return c.inters.UserLoginProfile
}

func (c *UserLoginProfileClient) mutate(ctx context.Context, m *UserLoginProfileMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserLoginProfileCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserLoginProfileUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserLoginProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserLoginProfileDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown UserLoginProfile mutation op: %q", m.Op())
	}
}

// UserPasswordClient is a client for the UserPassword schema.
type UserPasswordClient struct {
	config
}

// NewUserPasswordClient returns a client for the UserPassword from the given config.
func NewUserPasswordClient(c config) *UserPasswordClient {
	return &UserPasswordClient{config: c}
}

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

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `userpassword.Intercept(f(g(h())))`.
func (c *UserPasswordClient) Intercept(interceptors ...Interceptor) {
	c.inters.UserPassword = append(c.inters.UserPassword, interceptors...)
}

// Create returns a builder for creating a UserPassword entity.
func (c *UserPasswordClient) Create() *UserPasswordCreate {
	mutation := newUserPasswordMutation(c.config, OpCreate)
	return &UserPasswordCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of UserPassword entities.
func (c *UserPasswordClient) CreateBulk(builders ...*UserPasswordCreate) *UserPasswordCreateBulk {
	return &UserPasswordCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *UserPasswordClient) MapCreateBulk(slice any, setFunc func(*UserPasswordCreate, int)) *UserPasswordCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserPasswordCreateBulk{err: fmt.Errorf("calling to UserPasswordClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserPasswordCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserPasswordCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for UserPassword.
func (c *UserPasswordClient) Update() *UserPasswordUpdate {
	mutation := newUserPasswordMutation(c.config, OpUpdate)
	return &UserPasswordUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserPasswordClient) UpdateOne(up *UserPassword) *UserPasswordUpdateOne {
	mutation := newUserPasswordMutation(c.config, OpUpdateOne, withUserPassword(up))
	return &UserPasswordUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserPasswordClient) UpdateOneID(id int) *UserPasswordUpdateOne {
	mutation := newUserPasswordMutation(c.config, OpUpdateOne, withUserPasswordID(id))
	return &UserPasswordUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for UserPassword.
func (c *UserPasswordClient) Delete() *UserPasswordDelete {
	mutation := newUserPasswordMutation(c.config, OpDelete)
	return &UserPasswordDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserPasswordClient) DeleteOne(up *UserPassword) *UserPasswordDeleteOne {
	return c.DeleteOneID(up.ID)
}

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

// Query returns a query builder for UserPassword.
func (c *UserPasswordClient) Query() *UserPasswordQuery {
	return &UserPasswordQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUserPassword},
		inters: c.Interceptors(),
	}
}

// Get returns a UserPassword entity by its id.
func (c *UserPasswordClient) Get(ctx context.Context, id int) (*UserPassword, error) {
	return c.Query().Where(userpassword.ID(id)).Only(entcache.WithEntryKey(ctx, "UserPassword", id))
}

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

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

// Hooks returns the client hooks.
func (c *UserPasswordClient) Hooks() []Hook {
	hooks := c.hooks.UserPassword
	return append(hooks[:len(hooks):len(hooks)], userpassword.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *UserPasswordClient) Interceptors() []Interceptor {
	return c.inters.UserPassword
}

func (c *UserPasswordClient) mutate(ctx context.Context, m *UserPasswordMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserPasswordCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserPasswordUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserPasswordUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserPasswordDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown UserPassword mutation op: %q", m.Op())
	}
}

// hooks and interceptors per client, for fast access.
type (
	hooks struct {
		App, AppAction, AppDict, AppDictItem, AppMenu, AppPolicy, AppRes, AppRole,
		AppRolePolicy, File, FileSource, OauthClient, Org, OrgApp, OrgPolicy, OrgRole,
		OrgRoleUser, OrgUser, OrgUserPreference, Permission, User, UserDevice,
		UserIdentity, UserLoginProfile, UserPassword []ent.Hook
	}
	inters struct {
		App, AppAction, AppDict, AppDictItem, AppMenu, AppPolicy, AppRes, AppRole,
		AppRolePolicy, File, FileSource, OauthClient, Org, OrgApp, OrgPolicy, OrgRole,
		OrgRoleUser, OrgUser, OrgUserPreference, Permission, User, UserDevice,
		UserIdentity, UserLoginProfile, UserPassword []ent.Interceptor
	}
)