client.go

// Code generated by ent, DO NOT EDIT.

package generated

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

	"github.com/datumforge/datum/internal/ent/generated/migrate"

	"net/http"

	"entgo.io/ent"
	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"github.com/datumforge/datum/internal/ent/generated/emailverificationtoken"
	"github.com/datumforge/datum/internal/ent/generated/entitlement"
	"github.com/datumforge/datum/internal/ent/generated/group"
	"github.com/datumforge/datum/internal/ent/generated/groupsetting"
	"github.com/datumforge/datum/internal/ent/generated/integration"
	"github.com/datumforge/datum/internal/ent/generated/oauthprovider"
	"github.com/datumforge/datum/internal/ent/generated/ohauthtootoken"
	"github.com/datumforge/datum/internal/ent/generated/organization"
	"github.com/datumforge/datum/internal/ent/generated/organizationsetting"
	"github.com/datumforge/datum/internal/ent/generated/personalaccesstoken"
	"github.com/datumforge/datum/internal/ent/generated/session"
	"github.com/datumforge/datum/internal/ent/generated/user"
	"github.com/datumforge/datum/internal/ent/generated/usersetting"
	"github.com/datumforge/datum/internal/fga"
	"go.uber.org/zap"
	"gocloud.dev/secrets"

	"github.com/datumforge/datum/internal/ent/generated/internal"
)

// 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
	// EmailVerificationToken is the client for interacting with the EmailVerificationToken builders.
	EmailVerificationToken *EmailVerificationTokenClient
	// Entitlement is the client for interacting with the Entitlement builders.
	Entitlement *EntitlementClient
	// Group is the client for interacting with the Group builders.
	Group *GroupClient
	// GroupSetting is the client for interacting with the GroupSetting builders.
	GroupSetting *GroupSettingClient
	// Integration is the client for interacting with the Integration builders.
	Integration *IntegrationClient
	// OauthProvider is the client for interacting with the OauthProvider builders.
	OauthProvider *OauthProviderClient
	// OhAuthTooToken is the client for interacting with the OhAuthTooToken builders.
	OhAuthTooToken *OhAuthTooTokenClient
	// Organization is the client for interacting with the Organization builders.
	Organization *OrganizationClient
	// OrganizationSetting is the client for interacting with the OrganizationSetting builders.
	OrganizationSetting *OrganizationSettingClient
	// PersonalAccessToken is the client for interacting with the PersonalAccessToken builders.
	PersonalAccessToken *PersonalAccessTokenClient
	// Session is the client for interacting with the Session builders.
	Session *SessionClient
	// User is the client for interacting with the User builders.
	User *UserClient
	// UserSetting is the client for interacting with the UserSetting builders.
	UserSetting *UserSettingClient
}

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

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.EmailVerificationToken = NewEmailVerificationTokenClient(c.config)
	c.Entitlement = NewEntitlementClient(c.config)
	c.Group = NewGroupClient(c.config)
	c.GroupSetting = NewGroupSettingClient(c.config)
	c.Integration = NewIntegrationClient(c.config)
	c.OauthProvider = NewOauthProviderClient(c.config)
	c.OhAuthTooToken = NewOhAuthTooTokenClient(c.config)
	c.Organization = NewOrganizationClient(c.config)
	c.OrganizationSetting = NewOrganizationSettingClient(c.config)
	c.PersonalAccessToken = NewPersonalAccessTokenClient(c.config)
	c.Session = NewSessionClient(c.config)
	c.User = NewUserClient(c.config)
	c.UserSetting = NewUserSettingClient(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
		SecretsKeeper *secrets.Keeper
		Authz         fga.Client
		Logger        zap.SugaredLogger
		HTTPClient    *http.Client
		// schemaConfig contains alternative names for all tables.
		schemaConfig SchemaConfig
	}
	// Option function to configure the client.
	Option func(*config)
)

// newConfig creates a new config for the client.
func newConfig(opts ...Option) config {
	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
	cfg.options(opts...)
	return cfg
}

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

// SecretsKeeper configures the SecretsKeeper.
func SecretsKeeper(v *secrets.Keeper) Option {
	return func(c *config) {
		c.SecretsKeeper = v
	}
}

// Authz configures the Authz.
func Authz(v fga.Client) Option {
	return func(c *config) {
		c.Authz = v
	}
}

// Logger configures the Logger.
func Logger(v zap.SugaredLogger) Option {
	return func(c *config) {
		c.Logger = v
	}
}

// HTTPClient configures the HTTPClient.
func HTTPClient(v *http.Client) Option {
	return func(c *config) {
		c.HTTPClient = v
	}
}

// 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("generated: 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("generated: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:                    ctx,
		config:                 cfg,
		EmailVerificationToken: NewEmailVerificationTokenClient(cfg),
		Entitlement:            NewEntitlementClient(cfg),
		Group:                  NewGroupClient(cfg),
		GroupSetting:           NewGroupSettingClient(cfg),
		Integration:            NewIntegrationClient(cfg),
		OauthProvider:          NewOauthProviderClient(cfg),
		OhAuthTooToken:         NewOhAuthTooTokenClient(cfg),
		Organization:           NewOrganizationClient(cfg),
		OrganizationSetting:    NewOrganizationSettingClient(cfg),
		PersonalAccessToken:    NewPersonalAccessTokenClient(cfg),
		Session:                NewSessionClient(cfg),
		User:                   NewUserClient(cfg),
		UserSetting:            NewUserSettingClient(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,
		EmailVerificationToken: NewEmailVerificationTokenClient(cfg),
		Entitlement:            NewEntitlementClient(cfg),
		Group:                  NewGroupClient(cfg),
		GroupSetting:           NewGroupSettingClient(cfg),
		Integration:            NewIntegrationClient(cfg),
		OauthProvider:          NewOauthProviderClient(cfg),
		OhAuthTooToken:         NewOhAuthTooTokenClient(cfg),
		Organization:           NewOrganizationClient(cfg),
		OrganizationSetting:    NewOrganizationSettingClient(cfg),
		PersonalAccessToken:    NewPersonalAccessTokenClient(cfg),
		Session:                NewSessionClient(cfg),
		User:                   NewUserClient(cfg),
		UserSetting:            NewUserSettingClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		EmailVerificationToken.
//		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.EmailVerificationToken, c.Entitlement, c.Group, c.GroupSetting, c.Integration,
		c.OauthProvider, c.OhAuthTooToken, c.Organization, c.OrganizationSetting,
		c.PersonalAccessToken, c.Session, c.User, c.UserSetting,
	} {
		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.EmailVerificationToken, c.Entitlement, c.Group, c.GroupSetting, c.Integration,
		c.OauthProvider, c.OhAuthTooToken, c.Organization, c.OrganizationSetting,
		c.PersonalAccessToken, c.Session, c.User, c.UserSetting,
	} {
		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 *EmailVerificationTokenMutation:
		return c.EmailVerificationToken.mutate(ctx, m)
	case *EntitlementMutation:
		return c.Entitlement.mutate(ctx, m)
	case *GroupMutation:
		return c.Group.mutate(ctx, m)
	case *GroupSettingMutation:
		return c.GroupSetting.mutate(ctx, m)
	case *IntegrationMutation:
		return c.Integration.mutate(ctx, m)
	case *OauthProviderMutation:
		return c.OauthProvider.mutate(ctx, m)
	case *OhAuthTooTokenMutation:
		return c.OhAuthTooToken.mutate(ctx, m)
	case *OrganizationMutation:
		return c.Organization.mutate(ctx, m)
	case *OrganizationSettingMutation:
		return c.OrganizationSetting.mutate(ctx, m)
	case *PersonalAccessTokenMutation:
		return c.PersonalAccessToken.mutate(ctx, m)
	case *SessionMutation:
		return c.Session.mutate(ctx, m)
	case *UserMutation:
		return c.User.mutate(ctx, m)
	case *UserSettingMutation:
		return c.UserSetting.mutate(ctx, m)
	default:
		return nil, fmt.Errorf("generated: unknown mutation type %T", m)
	}
}

// EmailVerificationTokenClient is a client for the EmailVerificationToken schema.
type EmailVerificationTokenClient struct {
	config
}

// NewEmailVerificationTokenClient returns a client for the EmailVerificationToken from the given config.
func NewEmailVerificationTokenClient(c config) *EmailVerificationTokenClient {
	return &EmailVerificationTokenClient{config: c}
}

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

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

// Create returns a builder for creating a EmailVerificationToken entity.
func (c *EmailVerificationTokenClient) Create() *EmailVerificationTokenCreate {
	mutation := newEmailVerificationTokenMutation(c.config, OpCreate)
	return &EmailVerificationTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of EmailVerificationToken entities.
func (c *EmailVerificationTokenClient) CreateBulk(builders ...*EmailVerificationTokenCreate) *EmailVerificationTokenCreateBulk {
	return &EmailVerificationTokenCreateBulk{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 *EmailVerificationTokenClient) MapCreateBulk(slice any, setFunc func(*EmailVerificationTokenCreate, int)) *EmailVerificationTokenCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &EmailVerificationTokenCreateBulk{err: fmt.Errorf("calling to EmailVerificationTokenClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*EmailVerificationTokenCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &EmailVerificationTokenCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for EmailVerificationToken.
func (c *EmailVerificationTokenClient) Update() *EmailVerificationTokenUpdate {
	mutation := newEmailVerificationTokenMutation(c.config, OpUpdate)
	return &EmailVerificationTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *EmailVerificationTokenClient) UpdateOne(evt *EmailVerificationToken) *EmailVerificationTokenUpdateOne {
	mutation := newEmailVerificationTokenMutation(c.config, OpUpdateOne, withEmailVerificationToken(evt))
	return &EmailVerificationTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *EmailVerificationTokenClient) UpdateOneID(id string) *EmailVerificationTokenUpdateOne {
	mutation := newEmailVerificationTokenMutation(c.config, OpUpdateOne, withEmailVerificationTokenID(id))
	return &EmailVerificationTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for EmailVerificationToken.
func (c *EmailVerificationTokenClient) Delete() *EmailVerificationTokenDelete {
	mutation := newEmailVerificationTokenMutation(c.config, OpDelete)
	return &EmailVerificationTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *EmailVerificationTokenClient) DeleteOne(evt *EmailVerificationToken) *EmailVerificationTokenDeleteOne {
	return c.DeleteOneID(evt.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *EmailVerificationTokenClient) DeleteOneID(id string) *EmailVerificationTokenDeleteOne {
	builder := c.Delete().Where(emailverificationtoken.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &EmailVerificationTokenDeleteOne{builder}
}

// Query returns a query builder for EmailVerificationToken.
func (c *EmailVerificationTokenClient) Query() *EmailVerificationTokenQuery {
	return &EmailVerificationTokenQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeEmailVerificationToken},
		inters: c.Interceptors(),
	}
}

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

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

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

// Hooks returns the client hooks.
func (c *EmailVerificationTokenClient) Hooks() []Hook {
	hooks := c.hooks.EmailVerificationToken
	return append(hooks[:len(hooks):len(hooks)], emailverificationtoken.Hooks[:]...)
}

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

func (c *EmailVerificationTokenClient) mutate(ctx context.Context, m *EmailVerificationTokenMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&EmailVerificationTokenCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&EmailVerificationTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&EmailVerificationTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&EmailVerificationTokenDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown EmailVerificationToken mutation op: %q", m.Op())
	}
}

// EntitlementClient is a client for the Entitlement schema.
type EntitlementClient struct {
	config
}

// NewEntitlementClient returns a client for the Entitlement from the given config.
func NewEntitlementClient(c config) *EntitlementClient {
	return &EntitlementClient{config: c}
}

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

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

// Create returns a builder for creating a Entitlement entity.
func (c *EntitlementClient) Create() *EntitlementCreate {
	mutation := newEntitlementMutation(c.config, OpCreate)
	return &EntitlementCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Entitlement entities.
func (c *EntitlementClient) CreateBulk(builders ...*EntitlementCreate) *EntitlementCreateBulk {
	return &EntitlementCreateBulk{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 *EntitlementClient) MapCreateBulk(slice any, setFunc func(*EntitlementCreate, int)) *EntitlementCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &EntitlementCreateBulk{err: fmt.Errorf("calling to EntitlementClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*EntitlementCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &EntitlementCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Entitlement.
func (c *EntitlementClient) Update() *EntitlementUpdate {
	mutation := newEntitlementMutation(c.config, OpUpdate)
	return &EntitlementUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *EntitlementClient) UpdateOne(e *Entitlement) *EntitlementUpdateOne {
	mutation := newEntitlementMutation(c.config, OpUpdateOne, withEntitlement(e))
	return &EntitlementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *EntitlementClient) UpdateOneID(id string) *EntitlementUpdateOne {
	mutation := newEntitlementMutation(c.config, OpUpdateOne, withEntitlementID(id))
	return &EntitlementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Entitlement.
func (c *EntitlementClient) Delete() *EntitlementDelete {
	mutation := newEntitlementMutation(c.config, OpDelete)
	return &EntitlementDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *EntitlementClient) DeleteOne(e *Entitlement) *EntitlementDeleteOne {
	return c.DeleteOneID(e.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *EntitlementClient) DeleteOneID(id string) *EntitlementDeleteOne {
	builder := c.Delete().Where(entitlement.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &EntitlementDeleteOne{builder}
}

// Query returns a query builder for Entitlement.
func (c *EntitlementClient) Query() *EntitlementQuery {
	return &EntitlementQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeEntitlement},
		inters: c.Interceptors(),
	}
}

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

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

// QueryOwner queries the owner edge of a Entitlement.
func (c *EntitlementClient) QueryOwner(e *Entitlement) *OrganizationQuery {
	query := (&OrganizationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(entitlement.Table, entitlement.FieldID, id),
			sqlgraph.To(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, entitlement.OwnerTable, entitlement.OwnerColumn),
		)
		schemaConfig := e.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.Entitlement
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *EntitlementClient) Hooks() []Hook {
	hooks := c.hooks.Entitlement
	return append(hooks[:len(hooks):len(hooks)], entitlement.Hooks[:]...)
}

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

func (c *EntitlementClient) mutate(ctx context.Context, m *EntitlementMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&EntitlementCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&EntitlementUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&EntitlementUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&EntitlementDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown Entitlement mutation op: %q", m.Op())
	}
}

// GroupClient is a client for the Group schema.
type GroupClient struct {
	config
}

// NewGroupClient returns a client for the Group from the given config.
func NewGroupClient(c config) *GroupClient {
	return &GroupClient{config: c}
}

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

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

// Create returns a builder for creating a Group entity.
func (c *GroupClient) Create() *GroupCreate {
	mutation := newGroupMutation(c.config, OpCreate)
	return &GroupCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Group entities.
func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk {
	return &GroupCreateBulk{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 *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*GroupCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &GroupCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Group.
func (c *GroupClient) Update() *GroupUpdate {
	mutation := newGroupMutation(c.config, OpUpdate)
	return &GroupUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *GroupClient) UpdateOne(gr *Group) *GroupUpdateOne {
	mutation := newGroupMutation(c.config, OpUpdateOne, withGroup(gr))
	return &GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *GroupClient) UpdateOneID(id string) *GroupUpdateOne {
	mutation := newGroupMutation(c.config, OpUpdateOne, withGroupID(id))
	return &GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Group.
func (c *GroupClient) Delete() *GroupDelete {
	mutation := newGroupMutation(c.config, OpDelete)
	return &GroupDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *GroupClient) DeleteOne(gr *Group) *GroupDeleteOne {
	return c.DeleteOneID(gr.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GroupClient) DeleteOneID(id string) *GroupDeleteOne {
	builder := c.Delete().Where(group.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &GroupDeleteOne{builder}
}

// Query returns a query builder for Group.
func (c *GroupClient) Query() *GroupQuery {
	return &GroupQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeGroup},
		inters: c.Interceptors(),
	}
}

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

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

// QuerySetting queries the setting edge of a Group.
func (c *GroupClient) QuerySetting(gr *Group) *GroupSettingQuery {
	query := (&GroupSettingClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := gr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(group.Table, group.FieldID, id),
			sqlgraph.To(groupsetting.Table, groupsetting.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, group.SettingTable, group.SettingColumn),
		)
		schemaConfig := gr.schemaConfig
		step.To.Schema = schemaConfig.GroupSetting
		step.Edge.Schema = schemaConfig.GroupSetting
		fromV = sqlgraph.Neighbors(gr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// QueryOwner queries the owner edge of a Group.
func (c *GroupClient) QueryOwner(gr *Group) *OrganizationQuery {
	query := (&OrganizationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := gr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(group.Table, group.FieldID, id),
			sqlgraph.To(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, group.OwnerTable, group.OwnerColumn),
		)
		schemaConfig := gr.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.Group
		fromV = sqlgraph.Neighbors(gr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *GroupClient) Hooks() []Hook {
	hooks := c.hooks.Group
	return append(hooks[:len(hooks):len(hooks)], group.Hooks[:]...)
}

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

func (c *GroupClient) mutate(ctx context.Context, m *GroupMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&GroupCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&GroupUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&GroupDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown Group mutation op: %q", m.Op())
	}
}

// GroupSettingClient is a client for the GroupSetting schema.
type GroupSettingClient struct {
	config
}

// NewGroupSettingClient returns a client for the GroupSetting from the given config.
func NewGroupSettingClient(c config) *GroupSettingClient {
	return &GroupSettingClient{config: c}
}

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

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

// Create returns a builder for creating a GroupSetting entity.
func (c *GroupSettingClient) Create() *GroupSettingCreate {
	mutation := newGroupSettingMutation(c.config, OpCreate)
	return &GroupSettingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of GroupSetting entities.
func (c *GroupSettingClient) CreateBulk(builders ...*GroupSettingCreate) *GroupSettingCreateBulk {
	return &GroupSettingCreateBulk{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 *GroupSettingClient) MapCreateBulk(slice any, setFunc func(*GroupSettingCreate, int)) *GroupSettingCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &GroupSettingCreateBulk{err: fmt.Errorf("calling to GroupSettingClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*GroupSettingCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &GroupSettingCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for GroupSetting.
func (c *GroupSettingClient) Update() *GroupSettingUpdate {
	mutation := newGroupSettingMutation(c.config, OpUpdate)
	return &GroupSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *GroupSettingClient) UpdateOne(gs *GroupSetting) *GroupSettingUpdateOne {
	mutation := newGroupSettingMutation(c.config, OpUpdateOne, withGroupSetting(gs))
	return &GroupSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *GroupSettingClient) UpdateOneID(id string) *GroupSettingUpdateOne {
	mutation := newGroupSettingMutation(c.config, OpUpdateOne, withGroupSettingID(id))
	return &GroupSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for GroupSetting.
func (c *GroupSettingClient) Delete() *GroupSettingDelete {
	mutation := newGroupSettingMutation(c.config, OpDelete)
	return &GroupSettingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *GroupSettingClient) DeleteOne(gs *GroupSetting) *GroupSettingDeleteOne {
	return c.DeleteOneID(gs.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GroupSettingClient) DeleteOneID(id string) *GroupSettingDeleteOne {
	builder := c.Delete().Where(groupsetting.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &GroupSettingDeleteOne{builder}
}

// Query returns a query builder for GroupSetting.
func (c *GroupSettingClient) Query() *GroupSettingQuery {
	return &GroupSettingQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeGroupSetting},
		inters: c.Interceptors(),
	}
}

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

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

// QueryGroup queries the group edge of a GroupSetting.
func (c *GroupSettingClient) QueryGroup(gs *GroupSetting) *GroupQuery {
	query := (&GroupClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := gs.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(groupsetting.Table, groupsetting.FieldID, id),
			sqlgraph.To(group.Table, group.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, groupsetting.GroupTable, groupsetting.GroupColumn),
		)
		schemaConfig := gs.schemaConfig
		step.To.Schema = schemaConfig.Group
		step.Edge.Schema = schemaConfig.GroupSetting
		fromV = sqlgraph.Neighbors(gs.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *GroupSettingClient) Hooks() []Hook {
	hooks := c.hooks.GroupSetting
	return append(hooks[:len(hooks):len(hooks)], groupsetting.Hooks[:]...)
}

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

func (c *GroupSettingClient) mutate(ctx context.Context, m *GroupSettingMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&GroupSettingCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&GroupSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&GroupSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&GroupSettingDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown GroupSetting mutation op: %q", m.Op())
	}
}

// IntegrationClient is a client for the Integration schema.
type IntegrationClient struct {
	config
}

// NewIntegrationClient returns a client for the Integration from the given config.
func NewIntegrationClient(c config) *IntegrationClient {
	return &IntegrationClient{config: c}
}

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

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

// Create returns a builder for creating a Integration entity.
func (c *IntegrationClient) Create() *IntegrationCreate {
	mutation := newIntegrationMutation(c.config, OpCreate)
	return &IntegrationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Integration entities.
func (c *IntegrationClient) CreateBulk(builders ...*IntegrationCreate) *IntegrationCreateBulk {
	return &IntegrationCreateBulk{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 *IntegrationClient) MapCreateBulk(slice any, setFunc func(*IntegrationCreate, int)) *IntegrationCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &IntegrationCreateBulk{err: fmt.Errorf("calling to IntegrationClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*IntegrationCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &IntegrationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Integration.
func (c *IntegrationClient) Update() *IntegrationUpdate {
	mutation := newIntegrationMutation(c.config, OpUpdate)
	return &IntegrationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *IntegrationClient) UpdateOne(i *Integration) *IntegrationUpdateOne {
	mutation := newIntegrationMutation(c.config, OpUpdateOne, withIntegration(i))
	return &IntegrationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *IntegrationClient) UpdateOneID(id string) *IntegrationUpdateOne {
	mutation := newIntegrationMutation(c.config, OpUpdateOne, withIntegrationID(id))
	return &IntegrationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Integration.
func (c *IntegrationClient) Delete() *IntegrationDelete {
	mutation := newIntegrationMutation(c.config, OpDelete)
	return &IntegrationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *IntegrationClient) DeleteOne(i *Integration) *IntegrationDeleteOne {
	return c.DeleteOneID(i.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *IntegrationClient) DeleteOneID(id string) *IntegrationDeleteOne {
	builder := c.Delete().Where(integration.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &IntegrationDeleteOne{builder}
}

// Query returns a query builder for Integration.
func (c *IntegrationClient) Query() *IntegrationQuery {
	return &IntegrationQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeIntegration},
		inters: c.Interceptors(),
	}
}

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

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

// QueryOwner queries the owner edge of a Integration.
func (c *IntegrationClient) QueryOwner(i *Integration) *OrganizationQuery {
	query := (&OrganizationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := i.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(integration.Table, integration.FieldID, id),
			sqlgraph.To(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, integration.OwnerTable, integration.OwnerColumn),
		)
		schemaConfig := i.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.Integration
		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *IntegrationClient) Hooks() []Hook {
	hooks := c.hooks.Integration
	return append(hooks[:len(hooks):len(hooks)], integration.Hooks[:]...)
}

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

func (c *IntegrationClient) mutate(ctx context.Context, m *IntegrationMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&IntegrationCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&IntegrationUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&IntegrationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&IntegrationDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown Integration mutation op: %q", m.Op())
	}
}

// OauthProviderClient is a client for the OauthProvider schema.
type OauthProviderClient struct {
	config
}

// NewOauthProviderClient returns a client for the OauthProvider from the given config.
func NewOauthProviderClient(c config) *OauthProviderClient {
	return &OauthProviderClient{config: c}
}

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

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

// Create returns a builder for creating a OauthProvider entity.
func (c *OauthProviderClient) Create() *OauthProviderCreate {
	mutation := newOauthProviderMutation(c.config, OpCreate)
	return &OauthProviderCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OauthProvider entities.
func (c *OauthProviderClient) CreateBulk(builders ...*OauthProviderCreate) *OauthProviderCreateBulk {
	return &OauthProviderCreateBulk{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 *OauthProviderClient) MapCreateBulk(slice any, setFunc func(*OauthProviderCreate, int)) *OauthProviderCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OauthProviderCreateBulk{err: fmt.Errorf("calling to OauthProviderClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OauthProviderCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OauthProviderCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OauthProvider.
func (c *OauthProviderClient) Update() *OauthProviderUpdate {
	mutation := newOauthProviderMutation(c.config, OpUpdate)
	return &OauthProviderUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OauthProviderClient) UpdateOne(op *OauthProvider) *OauthProviderUpdateOne {
	mutation := newOauthProviderMutation(c.config, OpUpdateOne, withOauthProvider(op))
	return &OauthProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OauthProviderClient) UpdateOneID(id string) *OauthProviderUpdateOne {
	mutation := newOauthProviderMutation(c.config, OpUpdateOne, withOauthProviderID(id))
	return &OauthProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OauthProvider.
func (c *OauthProviderClient) Delete() *OauthProviderDelete {
	mutation := newOauthProviderMutation(c.config, OpDelete)
	return &OauthProviderDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OauthProviderClient) DeleteOne(op *OauthProvider) *OauthProviderDeleteOne {
	return c.DeleteOneID(op.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *OauthProviderClient) DeleteOneID(id string) *OauthProviderDeleteOne {
	builder := c.Delete().Where(oauthprovider.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &OauthProviderDeleteOne{builder}
}

// Query returns a query builder for OauthProvider.
func (c *OauthProviderClient) Query() *OauthProviderQuery {
	return &OauthProviderQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOauthProvider},
		inters: c.Interceptors(),
	}
}

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

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

// QueryOwner queries the owner edge of a OauthProvider.
func (c *OauthProviderClient) QueryOwner(op *OauthProvider) *OrganizationQuery {
	query := (&OrganizationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := op.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(oauthprovider.Table, oauthprovider.FieldID, id),
			sqlgraph.To(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, oauthprovider.OwnerTable, oauthprovider.OwnerColumn),
		)
		schemaConfig := op.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.OauthProvider
		fromV = sqlgraph.Neighbors(op.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OauthProviderClient) Hooks() []Hook {
	hooks := c.hooks.OauthProvider
	return append(hooks[:len(hooks):len(hooks)], oauthprovider.Hooks[:]...)
}

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

func (c *OauthProviderClient) mutate(ctx context.Context, m *OauthProviderMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OauthProviderCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OauthProviderUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OauthProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OauthProviderDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown OauthProvider mutation op: %q", m.Op())
	}
}

// OhAuthTooTokenClient is a client for the OhAuthTooToken schema.
type OhAuthTooTokenClient struct {
	config
}

// NewOhAuthTooTokenClient returns a client for the OhAuthTooToken from the given config.
func NewOhAuthTooTokenClient(c config) *OhAuthTooTokenClient {
	return &OhAuthTooTokenClient{config: c}
}

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

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

// Create returns a builder for creating a OhAuthTooToken entity.
func (c *OhAuthTooTokenClient) Create() *OhAuthTooTokenCreate {
	mutation := newOhAuthTooTokenMutation(c.config, OpCreate)
	return &OhAuthTooTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OhAuthTooToken entities.
func (c *OhAuthTooTokenClient) CreateBulk(builders ...*OhAuthTooTokenCreate) *OhAuthTooTokenCreateBulk {
	return &OhAuthTooTokenCreateBulk{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 *OhAuthTooTokenClient) MapCreateBulk(slice any, setFunc func(*OhAuthTooTokenCreate, int)) *OhAuthTooTokenCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OhAuthTooTokenCreateBulk{err: fmt.Errorf("calling to OhAuthTooTokenClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OhAuthTooTokenCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OhAuthTooTokenCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OhAuthTooToken.
func (c *OhAuthTooTokenClient) Update() *OhAuthTooTokenUpdate {
	mutation := newOhAuthTooTokenMutation(c.config, OpUpdate)
	return &OhAuthTooTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OhAuthTooTokenClient) UpdateOne(oatt *OhAuthTooToken) *OhAuthTooTokenUpdateOne {
	mutation := newOhAuthTooTokenMutation(c.config, OpUpdateOne, withOhAuthTooToken(oatt))
	return &OhAuthTooTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OhAuthTooTokenClient) UpdateOneID(id string) *OhAuthTooTokenUpdateOne {
	mutation := newOhAuthTooTokenMutation(c.config, OpUpdateOne, withOhAuthTooTokenID(id))
	return &OhAuthTooTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OhAuthTooToken.
func (c *OhAuthTooTokenClient) Delete() *OhAuthTooTokenDelete {
	mutation := newOhAuthTooTokenMutation(c.config, OpDelete)
	return &OhAuthTooTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OhAuthTooTokenClient) DeleteOne(oatt *OhAuthTooToken) *OhAuthTooTokenDeleteOne {
	return c.DeleteOneID(oatt.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *OhAuthTooTokenClient) DeleteOneID(id string) *OhAuthTooTokenDeleteOne {
	builder := c.Delete().Where(ohauthtootoken.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &OhAuthTooTokenDeleteOne{builder}
}

// Query returns a query builder for OhAuthTooToken.
func (c *OhAuthTooTokenClient) Query() *OhAuthTooTokenQuery {
	return &OhAuthTooTokenQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOhAuthTooToken},
		inters: c.Interceptors(),
	}
}

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

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

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

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

func (c *OhAuthTooTokenClient) mutate(ctx context.Context, m *OhAuthTooTokenMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OhAuthTooTokenCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OhAuthTooTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OhAuthTooTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OhAuthTooTokenDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown OhAuthTooToken mutation op: %q", m.Op())
	}
}

// OrganizationClient is a client for the Organization schema.
type OrganizationClient struct {
	config
}

// NewOrganizationClient returns a client for the Organization from the given config.
func NewOrganizationClient(c config) *OrganizationClient {
	return &OrganizationClient{config: c}
}

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

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

// Create returns a builder for creating a Organization entity.
func (c *OrganizationClient) Create() *OrganizationCreate {
	mutation := newOrganizationMutation(c.config, OpCreate)
	return &OrganizationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Organization entities.
func (c *OrganizationClient) CreateBulk(builders ...*OrganizationCreate) *OrganizationCreateBulk {
	return &OrganizationCreateBulk{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 *OrganizationClient) MapCreateBulk(slice any, setFunc func(*OrganizationCreate, int)) *OrganizationCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrganizationCreateBulk{err: fmt.Errorf("calling to OrganizationClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrganizationCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrganizationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Organization.
func (c *OrganizationClient) Update() *OrganizationUpdate {
	mutation := newOrganizationMutation(c.config, OpUpdate)
	return &OrganizationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrganizationClient) UpdateOne(o *Organization) *OrganizationUpdateOne {
	mutation := newOrganizationMutation(c.config, OpUpdateOne, withOrganization(o))
	return &OrganizationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrganizationClient) UpdateOneID(id string) *OrganizationUpdateOne {
	mutation := newOrganizationMutation(c.config, OpUpdateOne, withOrganizationID(id))
	return &OrganizationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Organization.
func (c *OrganizationClient) Delete() *OrganizationDelete {
	mutation := newOrganizationMutation(c.config, OpDelete)
	return &OrganizationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrganizationClient) DeleteOne(o *Organization) *OrganizationDeleteOne {
	return c.DeleteOneID(o.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *OrganizationClient) DeleteOneID(id string) *OrganizationDeleteOne {
	builder := c.Delete().Where(organization.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &OrganizationDeleteOne{builder}
}

// Query returns a query builder for Organization.
func (c *OrganizationClient) Query() *OrganizationQuery {
	return &OrganizationQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrganization},
		inters: c.Interceptors(),
	}
}

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

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

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

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

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

// QueryGroups queries the groups edge of a Organization.
func (c *OrganizationClient) QueryGroups(o *Organization) *GroupQuery {
	query := (&GroupClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organization.Table, organization.FieldID, id),
			sqlgraph.To(group.Table, group.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, organization.GroupsTable, organization.GroupsColumn),
		)
		schemaConfig := o.schemaConfig
		step.To.Schema = schemaConfig.Group
		step.Edge.Schema = schemaConfig.Group
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryIntegrations queries the integrations edge of a Organization.
func (c *OrganizationClient) QueryIntegrations(o *Organization) *IntegrationQuery {
	query := (&IntegrationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organization.Table, organization.FieldID, id),
			sqlgraph.To(integration.Table, integration.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, organization.IntegrationsTable, organization.IntegrationsColumn),
		)
		schemaConfig := o.schemaConfig
		step.To.Schema = schemaConfig.Integration
		step.Edge.Schema = schemaConfig.Integration
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySetting queries the setting edge of a Organization.
func (c *OrganizationClient) QuerySetting(o *Organization) *OrganizationSettingQuery {
	query := (&OrganizationSettingClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organization.Table, organization.FieldID, id),
			sqlgraph.To(organizationsetting.Table, organizationsetting.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, organization.SettingTable, organization.SettingColumn),
		)
		schemaConfig := o.schemaConfig
		step.To.Schema = schemaConfig.OrganizationSetting
		step.Edge.Schema = schemaConfig.OrganizationSetting
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEntitlements queries the entitlements edge of a Organization.
func (c *OrganizationClient) QueryEntitlements(o *Organization) *EntitlementQuery {
	query := (&EntitlementClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organization.Table, organization.FieldID, id),
			sqlgraph.To(entitlement.Table, entitlement.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, organization.EntitlementsTable, organization.EntitlementsColumn),
		)
		schemaConfig := o.schemaConfig
		step.To.Schema = schemaConfig.Entitlement
		step.Edge.Schema = schemaConfig.Entitlement
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOauthprovider queries the oauthprovider edge of a Organization.
func (c *OrganizationClient) QueryOauthprovider(o *Organization) *OauthProviderQuery {
	query := (&OauthProviderClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := o.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organization.Table, organization.FieldID, id),
			sqlgraph.To(oauthprovider.Table, oauthprovider.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, organization.OauthproviderTable, organization.OauthproviderColumn),
		)
		schemaConfig := o.schemaConfig
		step.To.Schema = schemaConfig.OauthProvider
		step.Edge.Schema = schemaConfig.OauthProvider
		fromV = sqlgraph.Neighbors(o.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrganizationClient) Hooks() []Hook {
	hooks := c.hooks.Organization
	return append(hooks[:len(hooks):len(hooks)], organization.Hooks[:]...)
}

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

func (c *OrganizationClient) mutate(ctx context.Context, m *OrganizationMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrganizationCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrganizationUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrganizationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrganizationDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown Organization mutation op: %q", m.Op())
	}
}

// OrganizationSettingClient is a client for the OrganizationSetting schema.
type OrganizationSettingClient struct {
	config
}

// NewOrganizationSettingClient returns a client for the OrganizationSetting from the given config.
func NewOrganizationSettingClient(c config) *OrganizationSettingClient {
	return &OrganizationSettingClient{config: c}
}

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

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

// Create returns a builder for creating a OrganizationSetting entity.
func (c *OrganizationSettingClient) Create() *OrganizationSettingCreate {
	mutation := newOrganizationSettingMutation(c.config, OpCreate)
	return &OrganizationSettingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of OrganizationSetting entities.
func (c *OrganizationSettingClient) CreateBulk(builders ...*OrganizationSettingCreate) *OrganizationSettingCreateBulk {
	return &OrganizationSettingCreateBulk{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 *OrganizationSettingClient) MapCreateBulk(slice any, setFunc func(*OrganizationSettingCreate, int)) *OrganizationSettingCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &OrganizationSettingCreateBulk{err: fmt.Errorf("calling to OrganizationSettingClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*OrganizationSettingCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &OrganizationSettingCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for OrganizationSetting.
func (c *OrganizationSettingClient) Update() *OrganizationSettingUpdate {
	mutation := newOrganizationSettingMutation(c.config, OpUpdate)
	return &OrganizationSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *OrganizationSettingClient) UpdateOne(os *OrganizationSetting) *OrganizationSettingUpdateOne {
	mutation := newOrganizationSettingMutation(c.config, OpUpdateOne, withOrganizationSetting(os))
	return &OrganizationSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *OrganizationSettingClient) UpdateOneID(id string) *OrganizationSettingUpdateOne {
	mutation := newOrganizationSettingMutation(c.config, OpUpdateOne, withOrganizationSettingID(id))
	return &OrganizationSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for OrganizationSetting.
func (c *OrganizationSettingClient) Delete() *OrganizationSettingDelete {
	mutation := newOrganizationSettingMutation(c.config, OpDelete)
	return &OrganizationSettingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *OrganizationSettingClient) DeleteOne(os *OrganizationSetting) *OrganizationSettingDeleteOne {
	return c.DeleteOneID(os.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *OrganizationSettingClient) DeleteOneID(id string) *OrganizationSettingDeleteOne {
	builder := c.Delete().Where(organizationsetting.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &OrganizationSettingDeleteOne{builder}
}

// Query returns a query builder for OrganizationSetting.
func (c *OrganizationSettingClient) Query() *OrganizationSettingQuery {
	return &OrganizationSettingQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeOrganizationSetting},
		inters: c.Interceptors(),
	}
}

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

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

// QueryOrganization queries the organization edge of a OrganizationSetting.
func (c *OrganizationSettingClient) QueryOrganization(os *OrganizationSetting) *OrganizationQuery {
	query := (&OrganizationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := os.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(organizationsetting.Table, organizationsetting.FieldID, id),
			sqlgraph.To(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, organizationsetting.OrganizationTable, organizationsetting.OrganizationColumn),
		)
		schemaConfig := os.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.OrganizationSetting
		fromV = sqlgraph.Neighbors(os.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *OrganizationSettingClient) Hooks() []Hook {
	hooks := c.hooks.OrganizationSetting
	return append(hooks[:len(hooks):len(hooks)], organizationsetting.Hooks[:]...)
}

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

func (c *OrganizationSettingClient) mutate(ctx context.Context, m *OrganizationSettingMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&OrganizationSettingCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&OrganizationSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&OrganizationSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&OrganizationSettingDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown OrganizationSetting mutation op: %q", m.Op())
	}
}

// PersonalAccessTokenClient is a client for the PersonalAccessToken schema.
type PersonalAccessTokenClient struct {
	config
}

// NewPersonalAccessTokenClient returns a client for the PersonalAccessToken from the given config.
func NewPersonalAccessTokenClient(c config) *PersonalAccessTokenClient {
	return &PersonalAccessTokenClient{config: c}
}

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

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

// Create returns a builder for creating a PersonalAccessToken entity.
func (c *PersonalAccessTokenClient) Create() *PersonalAccessTokenCreate {
	mutation := newPersonalAccessTokenMutation(c.config, OpCreate)
	return &PersonalAccessTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of PersonalAccessToken entities.
func (c *PersonalAccessTokenClient) CreateBulk(builders ...*PersonalAccessTokenCreate) *PersonalAccessTokenCreateBulk {
	return &PersonalAccessTokenCreateBulk{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 *PersonalAccessTokenClient) MapCreateBulk(slice any, setFunc func(*PersonalAccessTokenCreate, int)) *PersonalAccessTokenCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &PersonalAccessTokenCreateBulk{err: fmt.Errorf("calling to PersonalAccessTokenClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*PersonalAccessTokenCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &PersonalAccessTokenCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for PersonalAccessToken.
func (c *PersonalAccessTokenClient) Update() *PersonalAccessTokenUpdate {
	mutation := newPersonalAccessTokenMutation(c.config, OpUpdate)
	return &PersonalAccessTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PersonalAccessTokenClient) UpdateOne(pat *PersonalAccessToken) *PersonalAccessTokenUpdateOne {
	mutation := newPersonalAccessTokenMutation(c.config, OpUpdateOne, withPersonalAccessToken(pat))
	return &PersonalAccessTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PersonalAccessTokenClient) UpdateOneID(id string) *PersonalAccessTokenUpdateOne {
	mutation := newPersonalAccessTokenMutation(c.config, OpUpdateOne, withPersonalAccessTokenID(id))
	return &PersonalAccessTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for PersonalAccessToken.
func (c *PersonalAccessTokenClient) Delete() *PersonalAccessTokenDelete {
	mutation := newPersonalAccessTokenMutation(c.config, OpDelete)
	return &PersonalAccessTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *PersonalAccessTokenClient) DeleteOne(pat *PersonalAccessToken) *PersonalAccessTokenDeleteOne {
	return c.DeleteOneID(pat.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *PersonalAccessTokenClient) DeleteOneID(id string) *PersonalAccessTokenDeleteOne {
	builder := c.Delete().Where(personalaccesstoken.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &PersonalAccessTokenDeleteOne{builder}
}

// Query returns a query builder for PersonalAccessToken.
func (c *PersonalAccessTokenClient) Query() *PersonalAccessTokenQuery {
	return &PersonalAccessTokenQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypePersonalAccessToken},
		inters: c.Interceptors(),
	}
}

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

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

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

// Hooks returns the client hooks.
func (c *PersonalAccessTokenClient) Hooks() []Hook {
	hooks := c.hooks.PersonalAccessToken
	return append(hooks[:len(hooks):len(hooks)], personalaccesstoken.Hooks[:]...)
}

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

func (c *PersonalAccessTokenClient) mutate(ctx context.Context, m *PersonalAccessTokenMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&PersonalAccessTokenCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&PersonalAccessTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&PersonalAccessTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&PersonalAccessTokenDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown PersonalAccessToken mutation op: %q", m.Op())
	}
}

// SessionClient is a client for the Session schema.
type SessionClient struct {
	config
}

// NewSessionClient returns a client for the Session from the given config.
func NewSessionClient(c config) *SessionClient {
	return &SessionClient{config: c}
}

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

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

// Create returns a builder for creating a Session entity.
func (c *SessionClient) Create() *SessionCreate {
	mutation := newSessionMutation(c.config, OpCreate)
	return &SessionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Session entities.
func (c *SessionClient) CreateBulk(builders ...*SessionCreate) *SessionCreateBulk {
	return &SessionCreateBulk{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 *SessionClient) MapCreateBulk(slice any, setFunc func(*SessionCreate, int)) *SessionCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &SessionCreateBulk{err: fmt.Errorf("calling to SessionClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*SessionCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &SessionCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Session.
func (c *SessionClient) Update() *SessionUpdate {
	mutation := newSessionMutation(c.config, OpUpdate)
	return &SessionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SessionClient) UpdateOne(s *Session) *SessionUpdateOne {
	mutation := newSessionMutation(c.config, OpUpdateOne, withSession(s))
	return &SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SessionClient) UpdateOneID(id string) *SessionUpdateOne {
	mutation := newSessionMutation(c.config, OpUpdateOne, withSessionID(id))
	return &SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Session.
func (c *SessionClient) Delete() *SessionDelete {
	mutation := newSessionMutation(c.config, OpDelete)
	return &SessionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SessionClient) DeleteOne(s *Session) *SessionDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SessionClient) DeleteOneID(id string) *SessionDeleteOne {
	builder := c.Delete().Where(session.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SessionDeleteOne{builder}
}

// Query returns a query builder for Session.
func (c *SessionClient) Query() *SessionQuery {
	return &SessionQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSession},
		inters: c.Interceptors(),
	}
}

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

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

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

// Hooks returns the client hooks.
func (c *SessionClient) Hooks() []Hook {
	hooks := c.hooks.Session
	return append(hooks[:len(hooks):len(hooks)], session.Hooks[:]...)
}

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

func (c *SessionClient) mutate(ctx context.Context, m *SessionMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SessionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SessionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SessionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SessionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown Session 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 string) *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 string) *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 string) (*User, error) {
	return c.Query().Where(user.ID(id)).Only(ctx)
}

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

// QueryOrganizations queries the organizations edge of a User.
func (c *UserClient) QueryOrganizations(u *User) *OrganizationQuery {
	query := (&OrganizationClient{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(organization.Table, organization.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, user.OrganizationsTable, user.OrganizationsPrimaryKey...),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.Organization
		step.Edge.Schema = schemaConfig.UserOrganizations
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySessions queries the sessions edge of a User.
func (c *UserClient) QuerySessions(u *User) *SessionQuery {
	query := (&SessionClient{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(session.Table, session.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.SessionsTable, user.SessionsColumn),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.Session
		step.Edge.Schema = schemaConfig.Session
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryGroups queries the groups edge of a User.
func (c *UserClient) QueryGroups(u *User) *GroupQuery {
	query := (&GroupClient{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(group.Table, group.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, user.GroupsTable, user.GroupsPrimaryKey...),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.Group
		step.Edge.Schema = schemaConfig.GroupUsers
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPersonalAccessTokens queries the personal_access_tokens edge of a User.
func (c *UserClient) QueryPersonalAccessTokens(u *User) *PersonalAccessTokenQuery {
	query := (&PersonalAccessTokenClient{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(personalaccesstoken.Table, personalaccesstoken.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.PersonalAccessTokensTable, user.PersonalAccessTokensColumn),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.PersonalAccessToken
		step.Edge.Schema = schemaConfig.PersonalAccessToken
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySetting queries the setting edge of a User.
func (c *UserClient) QuerySetting(u *User) *UserSettingQuery {
	query := (&UserSettingClient{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(usersetting.Table, usersetting.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, user.SettingTable, user.SettingColumn),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.UserSetting
		step.Edge.Schema = schemaConfig.UserSetting
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEmailVerificationTokens queries the email_verification_tokens edge of a User.
func (c *UserClient) QueryEmailVerificationTokens(u *User) *EmailVerificationTokenQuery {
	query := (&EmailVerificationTokenClient{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(emailverificationtoken.Table, emailverificationtoken.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.EmailVerificationTokensTable, user.EmailVerificationTokensColumn),
		)
		schemaConfig := u.schemaConfig
		step.To.Schema = schemaConfig.EmailVerificationToken
		step.Edge.Schema = schemaConfig.EmailVerificationToken
		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("generated: unknown User mutation op: %q", m.Op())
	}
}

// UserSettingClient is a client for the UserSetting schema.
type UserSettingClient struct {
	config
}

// NewUserSettingClient returns a client for the UserSetting from the given config.
func NewUserSettingClient(c config) *UserSettingClient {
	return &UserSettingClient{config: c}
}

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

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

// Create returns a builder for creating a UserSetting entity.
func (c *UserSettingClient) Create() *UserSettingCreate {
	mutation := newUserSettingMutation(c.config, OpCreate)
	return &UserSettingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of UserSetting entities.
func (c *UserSettingClient) CreateBulk(builders ...*UserSettingCreate) *UserSettingCreateBulk {
	return &UserSettingCreateBulk{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 *UserSettingClient) MapCreateBulk(slice any, setFunc func(*UserSettingCreate, int)) *UserSettingCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &UserSettingCreateBulk{err: fmt.Errorf("calling to UserSettingClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*UserSettingCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &UserSettingCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for UserSetting.
func (c *UserSettingClient) Update() *UserSettingUpdate {
	mutation := newUserSettingMutation(c.config, OpUpdate)
	return &UserSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *UserSettingClient) UpdateOne(us *UserSetting) *UserSettingUpdateOne {
	mutation := newUserSettingMutation(c.config, OpUpdateOne, withUserSetting(us))
	return &UserSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *UserSettingClient) UpdateOneID(id string) *UserSettingUpdateOne {
	mutation := newUserSettingMutation(c.config, OpUpdateOne, withUserSettingID(id))
	return &UserSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for UserSetting.
func (c *UserSettingClient) Delete() *UserSettingDelete {
	mutation := newUserSettingMutation(c.config, OpDelete)
	return &UserSettingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *UserSettingClient) DeleteOne(us *UserSetting) *UserSettingDeleteOne {
	return c.DeleteOneID(us.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *UserSettingClient) DeleteOneID(id string) *UserSettingDeleteOne {
	builder := c.Delete().Where(usersetting.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &UserSettingDeleteOne{builder}
}

// Query returns a query builder for UserSetting.
func (c *UserSettingClient) Query() *UserSettingQuery {
	return &UserSettingQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeUserSetting},
		inters: c.Interceptors(),
	}
}

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

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

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

// Hooks returns the client hooks.
func (c *UserSettingClient) Hooks() []Hook {
	hooks := c.hooks.UserSetting
	return append(hooks[:len(hooks):len(hooks)], usersetting.Hooks[:]...)
}

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

func (c *UserSettingClient) mutate(ctx context.Context, m *UserSettingMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&UserSettingCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&UserSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&UserSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&UserSettingDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("generated: unknown UserSetting mutation op: %q", m.Op())
	}
}

// hooks and interceptors per client, for fast access.
type (
	hooks struct {
		EmailVerificationToken, Entitlement, Group, GroupSetting, Integration,
		OauthProvider, OhAuthTooToken, Organization, OrganizationSetting,
		PersonalAccessToken, Session, User, UserSetting []ent.Hook
	}
	inters struct {
		EmailVerificationToken, Entitlement, Group, GroupSetting, Integration,
		OauthProvider, OhAuthTooToken, Organization, OrganizationSetting,
		PersonalAccessToken, Session, User, UserSetting []ent.Interceptor
	}
)

// SchemaConfig represents alternative schema names for all tables
// that can be passed at runtime.
type SchemaConfig = internal.SchemaConfig

// AlternateSchemas allows alternate schema names to be
// passed into ent operations.
func AlternateSchema(schemaConfig SchemaConfig) Option {
	return func(c *config) {
		c.schemaConfig = schemaConfig
	}
}