// Code generated by ent, DO NOT EDIT.

package ent

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

	"git.dotya.ml/mirre-mt/pcmt/ent/migrate"
	"github.com/google/uuid"

	"entgo.io/ent"
	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"git.dotya.ml/mirre-mt/pcmt/ent/agekey"
	"git.dotya.ml/mirre-mt/pcmt/ent/hibp"
	"git.dotya.ml/mirre-mt/pcmt/ent/localbreach"
	"git.dotya.ml/mirre-mt/pcmt/ent/searchquery"
	"git.dotya.ml/mirre-mt/pcmt/ent/settings"
	"git.dotya.ml/mirre-mt/pcmt/ent/setup"
	"git.dotya.ml/mirre-mt/pcmt/ent/trackedbreaches"
	"git.dotya.ml/mirre-mt/pcmt/ent/user"
)

// 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
	// AgeKey is the client for interacting with the AgeKey builders.
	AgeKey *AgeKeyClient
	// HIBP is the client for interacting with the HIBP builders.
	HIBP *HIBPClient
	// LocalBreach is the client for interacting with the LocalBreach builders.
	LocalBreach *LocalBreachClient
	// SearchQuery is the client for interacting with the SearchQuery builders.
	SearchQuery *SearchQueryClient
	// Settings is the client for interacting with the Settings builders.
	Settings *SettingsClient
	// Setup is the client for interacting with the Setup builders.
	Setup *SetupClient
	// TrackedBreaches is the client for interacting with the TrackedBreaches builders.
	TrackedBreaches *TrackedBreachesClient
	// User is the client for interacting with the User builders.
	User *UserClient
}

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

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.AgeKey = NewAgeKeyClient(c.config)
	c.HIBP = NewHIBPClient(c.config)
	c.LocalBreach = NewLocalBreachClient(c.config)
	c.SearchQuery = NewSearchQueryClient(c.config)
	c.Settings = NewSettingsClient(c.config)
	c.Setup = NewSetupClient(c.config)
	c.TrackedBreaches = NewTrackedBreachesClient(c.config)
	c.User = NewUserClient(c.config)
}

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

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

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

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

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

// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
	switch driverName {
	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
		drv, err := sql.Open(driverName, dataSourceName)
		if err != nil {
			return nil, err
		}
		return NewClient(append(options, Driver(drv))...), nil
	default:
		return nil, fmt.Errorf("unsupported driver: %q", driverName)
	}
}

// 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, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := newTx(ctx, c.driver)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:             ctx,
		config:          cfg,
		AgeKey:          NewAgeKeyClient(cfg),
		HIBP:            NewHIBPClient(cfg),
		LocalBreach:     NewLocalBreachClient(cfg),
		SearchQuery:     NewSearchQueryClient(cfg),
		Settings:        NewSettingsClient(cfg),
		Setup:           NewSetupClient(cfg),
		TrackedBreaches: NewTrackedBreachesClient(cfg),
		User:            NewUserClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, 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,
		AgeKey:          NewAgeKeyClient(cfg),
		HIBP:            NewHIBPClient(cfg),
		LocalBreach:     NewLocalBreachClient(cfg),
		SearchQuery:     NewSearchQueryClient(cfg),
		Settings:        NewSettingsClient(cfg),
		Setup:           NewSetupClient(cfg),
		TrackedBreaches: NewTrackedBreachesClient(cfg),
		User:            NewUserClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		AgeKey.
//		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.AgeKey, c.HIBP, c.LocalBreach, c.SearchQuery, c.Settings, c.Setup,
		c.TrackedBreaches, c.User,
	} {
		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.AgeKey, c.HIBP, c.LocalBreach, c.SearchQuery, c.Settings, c.Setup,
		c.TrackedBreaches, c.User,
	} {
		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 *AgeKeyMutation:
		return c.AgeKey.mutate(ctx, m)
	case *HIBPMutation:
		return c.HIBP.mutate(ctx, m)
	case *LocalBreachMutation:
		return c.LocalBreach.mutate(ctx, m)
	case *SearchQueryMutation:
		return c.SearchQuery.mutate(ctx, m)
	case *SettingsMutation:
		return c.Settings.mutate(ctx, m)
	case *SetupMutation:
		return c.Setup.mutate(ctx, m)
	case *TrackedBreachesMutation:
		return c.TrackedBreaches.mutate(ctx, m)
	case *UserMutation:
		return c.User.mutate(ctx, m)
	default:
		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
	}
}

// AgeKeyClient is a client for the AgeKey schema.
type AgeKeyClient struct {
	config
}

// NewAgeKeyClient returns a client for the AgeKey from the given config.
func NewAgeKeyClient(c config) *AgeKeyClient {
	return &AgeKeyClient{config: c}
}

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

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

// Create returns a builder for creating a AgeKey entity.
func (c *AgeKeyClient) Create() *AgeKeyCreate {
	mutation := newAgeKeyMutation(c.config, OpCreate)
	return &AgeKeyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of AgeKey entities.
func (c *AgeKeyClient) CreateBulk(builders ...*AgeKeyCreate) *AgeKeyCreateBulk {
	return &AgeKeyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for AgeKey.
func (c *AgeKeyClient) Update() *AgeKeyUpdate {
	mutation := newAgeKeyMutation(c.config, OpUpdate)
	return &AgeKeyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AgeKeyClient) UpdateOne(ak *AgeKey) *AgeKeyUpdateOne {
	mutation := newAgeKeyMutation(c.config, OpUpdateOne, withAgeKey(ak))
	return &AgeKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AgeKeyClient) UpdateOneID(id uuid.UUID) *AgeKeyUpdateOne {
	mutation := newAgeKeyMutation(c.config, OpUpdateOne, withAgeKeyID(id))
	return &AgeKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for AgeKey.
func (c *AgeKeyClient) Delete() *AgeKeyDelete {
	mutation := newAgeKeyMutation(c.config, OpDelete)
	return &AgeKeyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *AgeKeyClient) DeleteOne(ak *AgeKey) *AgeKeyDeleteOne {
	return c.DeleteOneID(ak.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *AgeKeyClient) DeleteOneID(id uuid.UUID) *AgeKeyDeleteOne {
	builder := c.Delete().Where(agekey.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &AgeKeyDeleteOne{builder}
}

// Query returns a query builder for AgeKey.
func (c *AgeKeyClient) Query() *AgeKeyQuery {
	return &AgeKeyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeAgeKey},
		inters: c.Interceptors(),
	}
}

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

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

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

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

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

func (c *AgeKeyClient) mutate(ctx context.Context, m *AgeKeyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&AgeKeyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&AgeKeyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&AgeKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&AgeKeyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown AgeKey mutation op: %q", m.Op())
	}
}

// HIBPClient is a client for the HIBP schema.
type HIBPClient struct {
	config
}

// NewHIBPClient returns a client for the HIBP from the given config.
func NewHIBPClient(c config) *HIBPClient {
	return &HIBPClient{config: c}
}

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

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

// Create returns a builder for creating a HIBP entity.
func (c *HIBPClient) Create() *HIBPCreate {
	mutation := newHIBPMutation(c.config, OpCreate)
	return &HIBPCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of HIBP entities.
func (c *HIBPClient) CreateBulk(builders ...*HIBPCreate) *HIBPCreateBulk {
	return &HIBPCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for HIBP.
func (c *HIBPClient) Update() *HIBPUpdate {
	mutation := newHIBPMutation(c.config, OpUpdate)
	return &HIBPUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *HIBPClient) UpdateOne(h *HIBP) *HIBPUpdateOne {
	mutation := newHIBPMutation(c.config, OpUpdateOne, withHIBP(h))
	return &HIBPUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *HIBPClient) UpdateOneID(id uuid.UUID) *HIBPUpdateOne {
	mutation := newHIBPMutation(c.config, OpUpdateOne, withHIBPID(id))
	return &HIBPUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for HIBP.
func (c *HIBPClient) Delete() *HIBPDelete {
	mutation := newHIBPMutation(c.config, OpDelete)
	return &HIBPDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *HIBPClient) DeleteOne(h *HIBP) *HIBPDeleteOne {
	return c.DeleteOneID(h.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *HIBPClient) DeleteOneID(id uuid.UUID) *HIBPDeleteOne {
	builder := c.Delete().Where(hibp.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &HIBPDeleteOne{builder}
}

// Query returns a query builder for HIBP.
func (c *HIBPClient) Query() *HIBPQuery {
	return &HIBPQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeHIBP},
		inters: c.Interceptors(),
	}
}

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

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

// QueryTrackedBreaches queries the tracked_breaches edge of a HIBP.
func (c *HIBPClient) QueryTrackedBreaches(h *HIBP) *TrackedBreachesQuery {
	query := (&TrackedBreachesClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := h.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(hibp.Table, hibp.FieldID, id),
			sqlgraph.To(trackedbreaches.Table, trackedbreaches.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, hibp.TrackedBreachesTable, hibp.TrackedBreachesColumn),
		)
		fromV = sqlgraph.Neighbors(h.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *HIBPClient) mutate(ctx context.Context, m *HIBPMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&HIBPCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&HIBPUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&HIBPUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&HIBPDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown HIBP mutation op: %q", m.Op())
	}
}

// LocalBreachClient is a client for the LocalBreach schema.
type LocalBreachClient struct {
	config
}

// NewLocalBreachClient returns a client for the LocalBreach from the given config.
func NewLocalBreachClient(c config) *LocalBreachClient {
	return &LocalBreachClient{config: c}
}

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

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

// Create returns a builder for creating a LocalBreach entity.
func (c *LocalBreachClient) Create() *LocalBreachCreate {
	mutation := newLocalBreachMutation(c.config, OpCreate)
	return &LocalBreachCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of LocalBreach entities.
func (c *LocalBreachClient) CreateBulk(builders ...*LocalBreachCreate) *LocalBreachCreateBulk {
	return &LocalBreachCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for LocalBreach.
func (c *LocalBreachClient) Update() *LocalBreachUpdate {
	mutation := newLocalBreachMutation(c.config, OpUpdate)
	return &LocalBreachUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *LocalBreachClient) UpdateOne(lb *LocalBreach) *LocalBreachUpdateOne {
	mutation := newLocalBreachMutation(c.config, OpUpdateOne, withLocalBreach(lb))
	return &LocalBreachUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *LocalBreachClient) UpdateOneID(id uuid.UUID) *LocalBreachUpdateOne {
	mutation := newLocalBreachMutation(c.config, OpUpdateOne, withLocalBreachID(id))
	return &LocalBreachUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for LocalBreach.
func (c *LocalBreachClient) Delete() *LocalBreachDelete {
	mutation := newLocalBreachMutation(c.config, OpDelete)
	return &LocalBreachDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *LocalBreachClient) DeleteOne(lb *LocalBreach) *LocalBreachDeleteOne {
	return c.DeleteOneID(lb.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *LocalBreachClient) DeleteOneID(id uuid.UUID) *LocalBreachDeleteOne {
	builder := c.Delete().Where(localbreach.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &LocalBreachDeleteOne{builder}
}

// Query returns a query builder for LocalBreach.
func (c *LocalBreachClient) Query() *LocalBreachQuery {
	return &LocalBreachQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeLocalBreach},
		inters: c.Interceptors(),
	}
}

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

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

// QueryTrackedBreaches queries the tracked_breaches edge of a LocalBreach.
func (c *LocalBreachClient) QueryTrackedBreaches(lb *LocalBreach) *TrackedBreachesQuery {
	query := (&TrackedBreachesClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := lb.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(localbreach.Table, localbreach.FieldID, id),
			sqlgraph.To(trackedbreaches.Table, trackedbreaches.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, localbreach.TrackedBreachesTable, localbreach.TrackedBreachesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(lb.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *LocalBreachClient) mutate(ctx context.Context, m *LocalBreachMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&LocalBreachCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&LocalBreachUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&LocalBreachUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&LocalBreachDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown LocalBreach mutation op: %q", m.Op())
	}
}

// SearchQueryClient is a client for the SearchQuery schema.
type SearchQueryClient struct {
	config
}

// NewSearchQueryClient returns a client for the SearchQuery from the given config.
func NewSearchQueryClient(c config) *SearchQueryClient {
	return &SearchQueryClient{config: c}
}

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

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

// Create returns a builder for creating a SearchQuery entity.
func (c *SearchQueryClient) Create() *SearchQueryCreate {
	mutation := newSearchQueryMutation(c.config, OpCreate)
	return &SearchQueryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of SearchQuery entities.
func (c *SearchQueryClient) CreateBulk(builders ...*SearchQueryCreate) *SearchQueryCreateBulk {
	return &SearchQueryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for SearchQuery.
func (c *SearchQueryClient) Update() *SearchQueryUpdate {
	mutation := newSearchQueryMutation(c.config, OpUpdate)
	return &SearchQueryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SearchQueryClient) UpdateOne(sq *SearchQuery) *SearchQueryUpdateOne {
	mutation := newSearchQueryMutation(c.config, OpUpdateOne, withSearchQuery(sq))
	return &SearchQueryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SearchQueryClient) UpdateOneID(id uuid.UUID) *SearchQueryUpdateOne {
	mutation := newSearchQueryMutation(c.config, OpUpdateOne, withSearchQueryID(id))
	return &SearchQueryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for SearchQuery.
func (c *SearchQueryClient) Delete() *SearchQueryDelete {
	mutation := newSearchQueryMutation(c.config, OpDelete)
	return &SearchQueryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SearchQueryClient) DeleteOne(sq *SearchQuery) *SearchQueryDeleteOne {
	return c.DeleteOneID(sq.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SearchQueryClient) DeleteOneID(id uuid.UUID) *SearchQueryDeleteOne {
	builder := c.Delete().Where(searchquery.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SearchQueryDeleteOne{builder}
}

// Query returns a query builder for SearchQuery.
func (c *SearchQueryClient) Query() *SearchQueryQuery {
	return &SearchQueryQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSearchQuery},
		inters: c.Interceptors(),
	}
}

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

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

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

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

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

func (c *SearchQueryClient) mutate(ctx context.Context, m *SearchQueryMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SearchQueryCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SearchQueryUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SearchQueryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SearchQueryDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown SearchQuery mutation op: %q", m.Op())
	}
}

// SettingsClient is a client for the Settings schema.
type SettingsClient struct {
	config
}

// NewSettingsClient returns a client for the Settings from the given config.
func NewSettingsClient(c config) *SettingsClient {
	return &SettingsClient{config: c}
}

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

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

// Create returns a builder for creating a Settings entity.
func (c *SettingsClient) Create() *SettingsCreate {
	mutation := newSettingsMutation(c.config, OpCreate)
	return &SettingsCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Settings entities.
func (c *SettingsClient) CreateBulk(builders ...*SettingsCreate) *SettingsCreateBulk {
	return &SettingsCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Settings.
func (c *SettingsClient) Update() *SettingsUpdate {
	mutation := newSettingsMutation(c.config, OpUpdate)
	return &SettingsUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SettingsClient) UpdateOne(s *Settings) *SettingsUpdateOne {
	mutation := newSettingsMutation(c.config, OpUpdateOne, withSettings(s))
	return &SettingsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SettingsClient) UpdateOneID(id uuid.UUID) *SettingsUpdateOne {
	mutation := newSettingsMutation(c.config, OpUpdateOne, withSettingsID(id))
	return &SettingsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Settings.
func (c *SettingsClient) Delete() *SettingsDelete {
	mutation := newSettingsMutation(c.config, OpDelete)
	return &SettingsDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SettingsClient) DeleteOne(s *Settings) *SettingsDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SettingsClient) DeleteOneID(id uuid.UUID) *SettingsDeleteOne {
	builder := c.Delete().Where(settings.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SettingsDeleteOne{builder}
}

// Query returns a query builder for Settings.
func (c *SettingsClient) Query() *SettingsQuery {
	return &SettingsQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSettings},
		inters: c.Interceptors(),
	}
}

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

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

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

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

func (c *SettingsClient) mutate(ctx context.Context, m *SettingsMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SettingsCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SettingsUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SettingsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SettingsDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Settings mutation op: %q", m.Op())
	}
}

// SetupClient is a client for the Setup schema.
type SetupClient struct {
	config
}

// NewSetupClient returns a client for the Setup from the given config.
func NewSetupClient(c config) *SetupClient {
	return &SetupClient{config: c}
}

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

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

// Create returns a builder for creating a Setup entity.
func (c *SetupClient) Create() *SetupCreate {
	mutation := newSetupMutation(c.config, OpCreate)
	return &SetupCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Setup entities.
func (c *SetupClient) CreateBulk(builders ...*SetupCreate) *SetupCreateBulk {
	return &SetupCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Setup.
func (c *SetupClient) Update() *SetupUpdate {
	mutation := newSetupMutation(c.config, OpUpdate)
	return &SetupUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SetupClient) UpdateOne(s *Setup) *SetupUpdateOne {
	mutation := newSetupMutation(c.config, OpUpdateOne, withSetup(s))
	return &SetupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SetupClient) UpdateOneID(id uuid.UUID) *SetupUpdateOne {
	mutation := newSetupMutation(c.config, OpUpdateOne, withSetupID(id))
	return &SetupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Setup.
func (c *SetupClient) Delete() *SetupDelete {
	mutation := newSetupMutation(c.config, OpDelete)
	return &SetupDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SetupClient) DeleteOne(s *Setup) *SetupDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SetupClient) DeleteOneID(id uuid.UUID) *SetupDeleteOne {
	builder := c.Delete().Where(setup.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SetupDeleteOne{builder}
}

// Query returns a query builder for Setup.
func (c *SetupClient) Query() *SetupQuery {
	return &SetupQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSetup},
		inters: c.Interceptors(),
	}
}

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

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

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

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

func (c *SetupClient) mutate(ctx context.Context, m *SetupMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SetupCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SetupUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SetupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SetupDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Setup mutation op: %q", m.Op())
	}
}

// TrackedBreachesClient is a client for the TrackedBreaches schema.
type TrackedBreachesClient struct {
	config
}

// NewTrackedBreachesClient returns a client for the TrackedBreaches from the given config.
func NewTrackedBreachesClient(c config) *TrackedBreachesClient {
	return &TrackedBreachesClient{config: c}
}

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

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

// Create returns a builder for creating a TrackedBreaches entity.
func (c *TrackedBreachesClient) Create() *TrackedBreachesCreate {
	mutation := newTrackedBreachesMutation(c.config, OpCreate)
	return &TrackedBreachesCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of TrackedBreaches entities.
func (c *TrackedBreachesClient) CreateBulk(builders ...*TrackedBreachesCreate) *TrackedBreachesCreateBulk {
	return &TrackedBreachesCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for TrackedBreaches.
func (c *TrackedBreachesClient) Update() *TrackedBreachesUpdate {
	mutation := newTrackedBreachesMutation(c.config, OpUpdate)
	return &TrackedBreachesUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *TrackedBreachesClient) UpdateOne(tb *TrackedBreaches) *TrackedBreachesUpdateOne {
	mutation := newTrackedBreachesMutation(c.config, OpUpdateOne, withTrackedBreaches(tb))
	return &TrackedBreachesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *TrackedBreachesClient) UpdateOneID(id uuid.UUID) *TrackedBreachesUpdateOne {
	mutation := newTrackedBreachesMutation(c.config, OpUpdateOne, withTrackedBreachesID(id))
	return &TrackedBreachesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for TrackedBreaches.
func (c *TrackedBreachesClient) Delete() *TrackedBreachesDelete {
	mutation := newTrackedBreachesMutation(c.config, OpDelete)
	return &TrackedBreachesDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *TrackedBreachesClient) DeleteOne(tb *TrackedBreaches) *TrackedBreachesDeleteOne {
	return c.DeleteOneID(tb.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TrackedBreachesClient) DeleteOneID(id uuid.UUID) *TrackedBreachesDeleteOne {
	builder := c.Delete().Where(trackedbreaches.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &TrackedBreachesDeleteOne{builder}
}

// Query returns a query builder for TrackedBreaches.
func (c *TrackedBreachesClient) Query() *TrackedBreachesQuery {
	return &TrackedBreachesQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeTrackedBreaches},
		inters: c.Interceptors(),
	}
}

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

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

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

// QueryLocalbreach queries the localbreach edge of a TrackedBreaches.
func (c *TrackedBreachesClient) QueryLocalbreach(tb *TrackedBreaches) *LocalBreachQuery {
	query := (&LocalBreachClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := tb.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(trackedbreaches.Table, trackedbreaches.FieldID, id),
			sqlgraph.To(localbreach.Table, localbreach.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, trackedbreaches.LocalbreachTable, trackedbreaches.LocalbreachPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(tb.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryHibp queries the hibp edge of a TrackedBreaches.
func (c *TrackedBreachesClient) QueryHibp(tb *TrackedBreaches) *HIBPQuery {
	query := (&HIBPClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := tb.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(trackedbreaches.Table, trackedbreaches.FieldID, id),
			sqlgraph.To(hibp.Table, hibp.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, trackedbreaches.HibpTable, trackedbreaches.HibpColumn),
		)
		fromV = sqlgraph.Neighbors(tb.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *TrackedBreachesClient) mutate(ctx context.Context, m *TrackedBreachesMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&TrackedBreachesCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&TrackedBreachesUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&TrackedBreachesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&TrackedBreachesDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown TrackedBreaches 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}
}

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

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

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

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

// DeleteOne returns a 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 uuid.UUID) *UserDeleteOne {
	builder := c.Delete().Where(user.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &UserDeleteOne{builder}
}

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

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

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

// QueryAgekey queries the agekey edge of a User.
func (c *UserClient) QueryAgekey(u *User) *AgeKeyQuery {
	query := (&AgeKeyClient{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(agekey.Table, agekey.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, user.AgekeyTable, user.AgekeyColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryTrackedBreaches queries the tracked_breaches edge of a User.
func (c *UserClient) QueryTrackedBreaches(u *User) *TrackedBreachesQuery {
	query := (&TrackedBreachesClient{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(trackedbreaches.Table, trackedbreaches.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.TrackedBreachesTable, user.TrackedBreachesColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QuerySearchQueries queries the search_queries edge of a User.
func (c *UserClient) QuerySearchQueries(u *User) *SearchQueryQuery {
	query := (&SearchQueryClient{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(searchquery.Table, searchquery.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, user.SearchQueriesTable, user.SearchQueriesColumn),
		)
		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

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

// hooks and interceptors per client, for fast access.
type (
	hooks struct {
		AgeKey, HIBP, LocalBreach, SearchQuery, Settings, Setup, TrackedBreaches,
		User []ent.Hook
	}
	inters struct {
		AgeKey, HIBP, LocalBreach, SearchQuery, Settings, Setup, TrackedBreaches,
		User []ent.Interceptor
	}
)