client.go

// Copyright 2019-present Facebook
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by entc, DO NOT EDIT.

package ent

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

	"github.com/diazoxide/entrefine/examples/ent-project/ent/migrate"
	"github.com/google/uuid"

	"github.com/diazoxide/entrefine/examples/ent-project/ent/company"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/country"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/email"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/image"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/location"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/phone"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/product"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/vendor"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/warehouse"
	"github.com/diazoxide/entrefine/examples/ent-project/ent/website"

	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
)

// Client is the client that holds all ent builders.
type Client struct {
	config
	// Schema is the client for creating, migrating and dropping schema.
	Schema *migrate.Schema
	// Company is the client for interacting with the Company builders.
	Company *CompanyClient
	// Country is the client for interacting with the Country builders.
	Country *CountryClient
	// Email is the client for interacting with the Email builders.
	Email *EmailClient
	// Image is the client for interacting with the Image builders.
	Image *ImageClient
	// Location is the client for interacting with the Location builders.
	Location *LocationClient
	// Phone is the client for interacting with the Phone builders.
	Phone *PhoneClient
	// Product is the client for interacting with the Product builders.
	Product *ProductClient
	// Vendor is the client for interacting with the Vendor builders.
	Vendor *VendorClient
	// Warehouse is the client for interacting with the Warehouse builders.
	Warehouse *WarehouseClient
	// Website is the client for interacting with the Website builders.
	Website *WebsiteClient
}

// 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.Company = NewCompanyClient(c.config)
	c.Country = NewCountryClient(c.config)
	c.Email = NewEmailClient(c.config)
	c.Image = NewImageClient(c.config)
	c.Location = NewLocationClient(c.config)
	c.Phone = NewPhoneClient(c.config)
	c.Product = NewProductClient(c.config)
	c.Vendor = NewVendorClient(c.config)
	c.Warehouse = NewWarehouseClient(c.config)
	c.Website = NewWebsiteClient(c.config)
}

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

// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, 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,
		Company:   NewCompanyClient(cfg),
		Country:   NewCountryClient(cfg),
		Email:     NewEmailClient(cfg),
		Image:     NewImageClient(cfg),
		Location:  NewLocationClient(cfg),
		Phone:     NewPhoneClient(cfg),
		Product:   NewProductClient(cfg),
		Vendor:    NewVendorClient(cfg),
		Warehouse: NewWarehouseClient(cfg),
		Website:   NewWebsiteClient(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,
		Company:   NewCompanyClient(cfg),
		Country:   NewCountryClient(cfg),
		Email:     NewEmailClient(cfg),
		Image:     NewImageClient(cfg),
		Location:  NewLocationClient(cfg),
		Phone:     NewPhoneClient(cfg),
		Product:   NewProductClient(cfg),
		Vendor:    NewVendorClient(cfg),
		Warehouse: NewWarehouseClient(cfg),
		Website:   NewWebsiteClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		Company.
//		Query().
//		Count(ctx)
func (c *Client) Debug() *Client {
	if c.debug {
		return c
	}
	cfg := c.config
	cfg.driver = dialect.Debug(c.driver, c.log)
	client := &Client{config: cfg}
	client.init()
	return client
}

// Close closes the database connection and prevents new queries from starting.
func (c *Client) Close() error {
	return c.driver.Close()
}

// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
	c.Company.Use(hooks...)
	c.Country.Use(hooks...)
	c.Email.Use(hooks...)
	c.Image.Use(hooks...)
	c.Location.Use(hooks...)
	c.Phone.Use(hooks...)
	c.Product.Use(hooks...)
	c.Vendor.Use(hooks...)
	c.Warehouse.Use(hooks...)
	c.Website.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) {
	c.Company.Intercept(interceptors...)
	c.Country.Intercept(interceptors...)
	c.Email.Intercept(interceptors...)
	c.Image.Intercept(interceptors...)
	c.Location.Intercept(interceptors...)
	c.Phone.Intercept(interceptors...)
	c.Product.Intercept(interceptors...)
	c.Vendor.Intercept(interceptors...)
	c.Warehouse.Intercept(interceptors...)
	c.Website.Intercept(interceptors...)
}

// Mutate implements the ent.Mutator interface.
func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
	switch m := m.(type) {
	case *CompanyMutation:
		return c.Company.mutate(ctx, m)
	case *CountryMutation:
		return c.Country.mutate(ctx, m)
	case *EmailMutation:
		return c.Email.mutate(ctx, m)
	case *ImageMutation:
		return c.Image.mutate(ctx, m)
	case *LocationMutation:
		return c.Location.mutate(ctx, m)
	case *PhoneMutation:
		return c.Phone.mutate(ctx, m)
	case *ProductMutation:
		return c.Product.mutate(ctx, m)
	case *VendorMutation:
		return c.Vendor.mutate(ctx, m)
	case *WarehouseMutation:
		return c.Warehouse.mutate(ctx, m)
	case *WebsiteMutation:
		return c.Website.mutate(ctx, m)
	default:
		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
	}
}

// CompanyClient is a client for the Company schema.
type CompanyClient struct {
	config
}

// NewCompanyClient returns a client for the Company from the given config.
func NewCompanyClient(c config) *CompanyClient {
	return &CompanyClient{config: c}
}

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

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

// Create returns a builder for creating a Company entity.
func (c *CompanyClient) Create() *CompanyCreate {
	mutation := newCompanyMutation(c.config, OpCreate)
	return &CompanyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Company entities.
func (c *CompanyClient) CreateBulk(builders ...*CompanyCreate) *CompanyCreateBulk {
	return &CompanyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Company.
func (c *CompanyClient) Update() *CompanyUpdate {
	mutation := newCompanyMutation(c.config, OpUpdate)
	return &CompanyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CompanyClient) UpdateOne(co *Company) *CompanyUpdateOne {
	mutation := newCompanyMutation(c.config, OpUpdateOne, withCompany(co))
	return &CompanyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CompanyClient) UpdateOneID(id uuid.UUID) *CompanyUpdateOne {
	mutation := newCompanyMutation(c.config, OpUpdateOne, withCompanyID(id))
	return &CompanyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Company.
func (c *CompanyClient) Delete() *CompanyDelete {
	mutation := newCompanyMutation(c.config, OpDelete)
	return &CompanyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CompanyClient) DeleteOne(co *Company) *CompanyDeleteOne {
	return c.DeleteOneID(co.ID)
}

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

// Query returns a query builder for Company.
func (c *CompanyClient) Query() *CompanyQuery {
	return &CompanyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeCompany},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCountries queries the countries edge of a Company.
func (c *CompanyClient) QueryCountries(co *Company) *CountryQuery {
	query := (&CountryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(country.Table, country.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, company.CountriesTable, company.CountriesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPhones queries the phones edge of a Company.
func (c *CompanyClient) QueryPhones(co *Company) *PhoneQuery {
	query := (&PhoneClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(phone.Table, phone.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, company.PhonesTable, company.PhonesColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEmails queries the emails edge of a Company.
func (c *CompanyClient) QueryEmails(co *Company) *EmailQuery {
	query := (&EmailClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(email.Table, email.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, company.EmailsTable, company.EmailsColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryWebsites queries the websites edge of a Company.
func (c *CompanyClient) QueryWebsites(co *Company) *WebsiteQuery {
	query := (&WebsiteClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(website.Table, website.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, company.WebsitesTable, company.WebsitesColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLocations queries the locations edge of a Company.
func (c *CompanyClient) QueryLocations(co *Company) *LocationQuery {
	query := (&LocationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(location.Table, location.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, company.LocationsTable, company.LocationsColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLogoImage queries the logo_image edge of a Company.
func (c *CompanyClient) QueryLogoImage(co *Company) *ImageQuery {
	query := (&ImageClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(image.Table, image.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, company.LogoImageTable, company.LogoImageColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCoverImage queries the cover_image edge of a Company.
func (c *CompanyClient) QueryCoverImage(co *Company) *ImageQuery {
	query := (&ImageClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(image.Table, image.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, false, company.CoverImageTable, company.CoverImageColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryGalleryImages queries the gallery_images edge of a Company.
func (c *CompanyClient) QueryGalleryImages(co *Company) *ImageQuery {
	query := (&ImageClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(company.Table, company.FieldID, id),
			sqlgraph.To(image.Table, image.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, company.GalleryImagesTable, company.GalleryImagesColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *CompanyClient) mutate(ctx context.Context, m *CompanyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&CompanyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&CompanyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&CompanyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&CompanyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Company mutation op: %q", m.Op())
	}
}

// CountryClient is a client for the Country schema.
type CountryClient struct {
	config
}

// NewCountryClient returns a client for the Country from the given config.
func NewCountryClient(c config) *CountryClient {
	return &CountryClient{config: c}
}

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

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

// Create returns a builder for creating a Country entity.
func (c *CountryClient) Create() *CountryCreate {
	mutation := newCountryMutation(c.config, OpCreate)
	return &CountryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Country entities.
func (c *CountryClient) CreateBulk(builders ...*CountryCreate) *CountryCreateBulk {
	return &CountryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Country.
func (c *CountryClient) Update() *CountryUpdate {
	mutation := newCountryMutation(c.config, OpUpdate)
	return &CountryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CountryClient) UpdateOne(co *Country) *CountryUpdateOne {
	mutation := newCountryMutation(c.config, OpUpdateOne, withCountry(co))
	return &CountryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CountryClient) UpdateOneID(id uuid.UUID) *CountryUpdateOne {
	mutation := newCountryMutation(c.config, OpUpdateOne, withCountryID(id))
	return &CountryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Country.
func (c *CountryClient) Delete() *CountryDelete {
	mutation := newCountryMutation(c.config, OpDelete)
	return &CountryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CountryClient) DeleteOne(co *Country) *CountryDeleteOne {
	return c.DeleteOneID(co.ID)
}

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

// Query returns a query builder for Country.
func (c *CountryClient) Query() *CountryQuery {
	return &CountryQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeCountry},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCompanies queries the companies edge of a Country.
func (c *CountryClient) QueryCompanies(co *Country) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(country.Table, country.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, country.CompaniesTable, country.CompaniesPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryPhones queries the phones edge of a Country.
func (c *CountryClient) QueryPhones(co *Country) *PhoneQuery {
	query := (&PhoneClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(country.Table, country.FieldID, id),
			sqlgraph.To(phone.Table, phone.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, country.PhonesTable, country.PhonesColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEmails queries the emails edge of a Country.
func (c *CountryClient) QueryEmails(co *Country) *EmailQuery {
	query := (&EmailClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(country.Table, country.FieldID, id),
			sqlgraph.To(email.Table, email.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, country.EmailsTable, country.EmailsColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryWebsites queries the websites edge of a Country.
func (c *CountryClient) QueryWebsites(co *Country) *WebsiteQuery {
	query := (&WebsiteClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(country.Table, country.FieldID, id),
			sqlgraph.To(website.Table, website.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, country.WebsitesTable, country.WebsitesColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLocations queries the locations edge of a Country.
func (c *CountryClient) QueryLocations(co *Country) *LocationQuery {
	query := (&LocationClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(country.Table, country.FieldID, id),
			sqlgraph.To(location.Table, location.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, country.LocationsTable, country.LocationsColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *CountryClient) mutate(ctx context.Context, m *CountryMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&CountryCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&CountryUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&CountryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&CountryDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Country mutation op: %q", m.Op())
	}
}

// EmailClient is a client for the Email schema.
type EmailClient struct {
	config
}

// NewEmailClient returns a client for the Email from the given config.
func NewEmailClient(c config) *EmailClient {
	return &EmailClient{config: c}
}

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

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

// Create returns a builder for creating a Email entity.
func (c *EmailClient) Create() *EmailCreate {
	mutation := newEmailMutation(c.config, OpCreate)
	return &EmailCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Email entities.
func (c *EmailClient) CreateBulk(builders ...*EmailCreate) *EmailCreateBulk {
	return &EmailCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Email.
func (c *EmailClient) Update() *EmailUpdate {
	mutation := newEmailMutation(c.config, OpUpdate)
	return &EmailUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *EmailClient) UpdateOne(e *Email) *EmailUpdateOne {
	mutation := newEmailMutation(c.config, OpUpdateOne, withEmail(e))
	return &EmailUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *EmailClient) UpdateOneID(id uuid.UUID) *EmailUpdateOne {
	mutation := newEmailMutation(c.config, OpUpdateOne, withEmailID(id))
	return &EmailUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Email.
func (c *EmailClient) Delete() *EmailDelete {
	mutation := newEmailMutation(c.config, OpDelete)
	return &EmailDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *EmailClient) DeleteOne(e *Email) *EmailDeleteOne {
	return c.DeleteOneID(e.ID)
}

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

// Query returns a query builder for Email.
func (c *EmailClient) Query() *EmailQuery {
	return &EmailQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeEmail},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCompany queries the company edge of a Email.
func (c *EmailClient) QueryCompany(e *Email) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(email.Table, email.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, email.CompanyTable, email.CompanyColumn),
		)
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCountry queries the country edge of a Email.
func (c *EmailClient) QueryCountry(e *Email) *CountryQuery {
	query := (&CountryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := e.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(email.Table, email.FieldID, id),
			sqlgraph.To(country.Table, country.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, email.CountryTable, email.CountryColumn),
		)
		fromV = sqlgraph.Neighbors(e.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *EmailClient) mutate(ctx context.Context, m *EmailMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&EmailCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&EmailUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&EmailUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&EmailDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Email mutation op: %q", m.Op())
	}
}

// ImageClient is a client for the Image schema.
type ImageClient struct {
	config
}

// NewImageClient returns a client for the Image from the given config.
func NewImageClient(c config) *ImageClient {
	return &ImageClient{config: c}
}

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

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

// Create returns a builder for creating a Image entity.
func (c *ImageClient) Create() *ImageCreate {
	mutation := newImageMutation(c.config, OpCreate)
	return &ImageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Image entities.
func (c *ImageClient) CreateBulk(builders ...*ImageCreate) *ImageCreateBulk {
	return &ImageCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Image.
func (c *ImageClient) Update() *ImageUpdate {
	mutation := newImageMutation(c.config, OpUpdate)
	return &ImageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ImageClient) UpdateOne(i *Image) *ImageUpdateOne {
	mutation := newImageMutation(c.config, OpUpdateOne, withImage(i))
	return &ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ImageClient) UpdateOneID(id uuid.UUID) *ImageUpdateOne {
	mutation := newImageMutation(c.config, OpUpdateOne, withImageID(id))
	return &ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Image.
func (c *ImageClient) Delete() *ImageDelete {
	mutation := newImageMutation(c.config, OpDelete)
	return &ImageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ImageClient) DeleteOne(i *Image) *ImageDeleteOne {
	return c.DeleteOneID(i.ID)
}

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

// Query returns a query builder for Image.
func (c *ImageClient) Query() *ImageQuery {
	return &ImageQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeImage},
		inters: c.Interceptors(),
	}
}

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

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

// QueryGalleryCompany queries the gallery_company edge of a Image.
func (c *ImageClient) QueryGalleryCompany(i *Image) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := i.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(image.Table, image.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, image.GalleryCompanyTable, image.GalleryCompanyColumn),
		)
		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryLogoCompany queries the logo_company edge of a Image.
func (c *ImageClient) QueryLogoCompany(i *Image) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := i.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(image.Table, image.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, image.LogoCompanyTable, image.LogoCompanyColumn),
		)
		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCoverCompany queries the cover_company edge of a Image.
func (c *ImageClient) QueryCoverCompany(i *Image) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := i.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(image.Table, image.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.O2O, true, image.CoverCompanyTable, image.CoverCompanyColumn),
		)
		fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *ImageClient) mutate(ctx context.Context, m *ImageMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&ImageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&ImageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&ImageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Image mutation op: %q", m.Op())
	}
}

// LocationClient is a client for the Location schema.
type LocationClient struct {
	config
}

// NewLocationClient returns a client for the Location from the given config.
func NewLocationClient(c config) *LocationClient {
	return &LocationClient{config: c}
}

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

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

// Create returns a builder for creating a Location entity.
func (c *LocationClient) Create() *LocationCreate {
	mutation := newLocationMutation(c.config, OpCreate)
	return &LocationCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Location entities.
func (c *LocationClient) CreateBulk(builders ...*LocationCreate) *LocationCreateBulk {
	return &LocationCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Location.
func (c *LocationClient) Update() *LocationUpdate {
	mutation := newLocationMutation(c.config, OpUpdate)
	return &LocationUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *LocationClient) UpdateOne(l *Location) *LocationUpdateOne {
	mutation := newLocationMutation(c.config, OpUpdateOne, withLocation(l))
	return &LocationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *LocationClient) UpdateOneID(id uuid.UUID) *LocationUpdateOne {
	mutation := newLocationMutation(c.config, OpUpdateOne, withLocationID(id))
	return &LocationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Location.
func (c *LocationClient) Delete() *LocationDelete {
	mutation := newLocationMutation(c.config, OpDelete)
	return &LocationDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *LocationClient) DeleteOne(l *Location) *LocationDeleteOne {
	return c.DeleteOneID(l.ID)
}

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

// Query returns a query builder for Location.
func (c *LocationClient) Query() *LocationQuery {
	return &LocationQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeLocation},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCompany queries the company edge of a Location.
func (c *LocationClient) QueryCompany(l *Location) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := l.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(location.Table, location.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, location.CompanyTable, location.CompanyColumn),
		)
		fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCountry queries the country edge of a Location.
func (c *LocationClient) QueryCountry(l *Location) *CountryQuery {
	query := (&CountryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := l.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(location.Table, location.FieldID, id),
			sqlgraph.To(country.Table, country.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, location.CountryTable, location.CountryColumn),
		)
		fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *LocationClient) mutate(ctx context.Context, m *LocationMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&LocationCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&LocationUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&LocationUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&LocationDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Location mutation op: %q", m.Op())
	}
}

// PhoneClient is a client for the Phone schema.
type PhoneClient struct {
	config
}

// NewPhoneClient returns a client for the Phone from the given config.
func NewPhoneClient(c config) *PhoneClient {
	return &PhoneClient{config: c}
}

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

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

// Create returns a builder for creating a Phone entity.
func (c *PhoneClient) Create() *PhoneCreate {
	mutation := newPhoneMutation(c.config, OpCreate)
	return &PhoneCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Phone entities.
func (c *PhoneClient) CreateBulk(builders ...*PhoneCreate) *PhoneCreateBulk {
	return &PhoneCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Phone.
func (c *PhoneClient) Update() *PhoneUpdate {
	mutation := newPhoneMutation(c.config, OpUpdate)
	return &PhoneUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PhoneClient) UpdateOne(ph *Phone) *PhoneUpdateOne {
	mutation := newPhoneMutation(c.config, OpUpdateOne, withPhone(ph))
	return &PhoneUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PhoneClient) UpdateOneID(id uuid.UUID) *PhoneUpdateOne {
	mutation := newPhoneMutation(c.config, OpUpdateOne, withPhoneID(id))
	return &PhoneUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Phone.
func (c *PhoneClient) Delete() *PhoneDelete {
	mutation := newPhoneMutation(c.config, OpDelete)
	return &PhoneDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *PhoneClient) DeleteOne(ph *Phone) *PhoneDeleteOne {
	return c.DeleteOneID(ph.ID)
}

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

// Query returns a query builder for Phone.
func (c *PhoneClient) Query() *PhoneQuery {
	return &PhoneQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypePhone},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCompany queries the company edge of a Phone.
func (c *PhoneClient) QueryCompany(ph *Phone) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ph.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(phone.Table, phone.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, phone.CompanyTable, phone.CompanyColumn),
		)
		fromV = sqlgraph.Neighbors(ph.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCountry queries the country edge of a Phone.
func (c *PhoneClient) QueryCountry(ph *Phone) *CountryQuery {
	query := (&CountryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ph.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(phone.Table, phone.FieldID, id),
			sqlgraph.To(country.Table, country.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, phone.CountryTable, phone.CountryColumn),
		)
		fromV = sqlgraph.Neighbors(ph.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *PhoneClient) mutate(ctx context.Context, m *PhoneMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&PhoneCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&PhoneUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&PhoneUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&PhoneDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Phone mutation op: %q", m.Op())
	}
}

// ProductClient is a client for the Product schema.
type ProductClient struct {
	config
}

// NewProductClient returns a client for the Product from the given config.
func NewProductClient(c config) *ProductClient {
	return &ProductClient{config: c}
}

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

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

// Create returns a builder for creating a Product entity.
func (c *ProductClient) Create() *ProductCreate {
	mutation := newProductMutation(c.config, OpCreate)
	return &ProductCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Product entities.
func (c *ProductClient) CreateBulk(builders ...*ProductCreate) *ProductCreateBulk {
	return &ProductCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Product.
func (c *ProductClient) Update() *ProductUpdate {
	mutation := newProductMutation(c.config, OpUpdate)
	return &ProductUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *ProductClient) UpdateOne(pr *Product) *ProductUpdateOne {
	mutation := newProductMutation(c.config, OpUpdateOne, withProduct(pr))
	return &ProductUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *ProductClient) UpdateOneID(id uuid.UUID) *ProductUpdateOne {
	mutation := newProductMutation(c.config, OpUpdateOne, withProductID(id))
	return &ProductUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Product.
func (c *ProductClient) Delete() *ProductDelete {
	mutation := newProductMutation(c.config, OpDelete)
	return &ProductDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *ProductClient) DeleteOne(pr *Product) *ProductDeleteOne {
	return c.DeleteOneID(pr.ID)
}

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

// Query returns a query builder for Product.
func (c *ProductClient) Query() *ProductQuery {
	return &ProductQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeProduct},
		inters: c.Interceptors(),
	}
}

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

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

// QueryWarehouse queries the warehouse edge of a Product.
func (c *ProductClient) QueryWarehouse(pr *Product) *WarehouseQuery {
	query := (&WarehouseClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(product.Table, product.FieldID, id),
			sqlgraph.To(warehouse.Table, warehouse.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, product.WarehouseTable, product.WarehouseColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryVendor queries the vendor edge of a Product.
func (c *ProductClient) QueryVendor(pr *Product) *VendorQuery {
	query := (&VendorClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(product.Table, product.FieldID, id),
			sqlgraph.To(vendor.Table, vendor.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, product.VendorTable, product.VendorColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *ProductClient) mutate(ctx context.Context, m *ProductMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&ProductCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&ProductUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&ProductUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&ProductDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Product mutation op: %q", m.Op())
	}
}

// VendorClient is a client for the Vendor schema.
type VendorClient struct {
	config
}

// NewVendorClient returns a client for the Vendor from the given config.
func NewVendorClient(c config) *VendorClient {
	return &VendorClient{config: c}
}

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

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

// Create returns a builder for creating a Vendor entity.
func (c *VendorClient) Create() *VendorCreate {
	mutation := newVendorMutation(c.config, OpCreate)
	return &VendorCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Vendor entities.
func (c *VendorClient) CreateBulk(builders ...*VendorCreate) *VendorCreateBulk {
	return &VendorCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Vendor.
func (c *VendorClient) Update() *VendorUpdate {
	mutation := newVendorMutation(c.config, OpUpdate)
	return &VendorUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *VendorClient) UpdateOne(v *Vendor) *VendorUpdateOne {
	mutation := newVendorMutation(c.config, OpUpdateOne, withVendor(v))
	return &VendorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *VendorClient) UpdateOneID(id uuid.UUID) *VendorUpdateOne {
	mutation := newVendorMutation(c.config, OpUpdateOne, withVendorID(id))
	return &VendorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Vendor.
func (c *VendorClient) Delete() *VendorDelete {
	mutation := newVendorMutation(c.config, OpDelete)
	return &VendorDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *VendorClient) DeleteOne(v *Vendor) *VendorDeleteOne {
	return c.DeleteOneID(v.ID)
}

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

// Query returns a query builder for Vendor.
func (c *VendorClient) Query() *VendorQuery {
	return &VendorQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeVendor},
		inters: c.Interceptors(),
	}
}

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

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

// QueryWarehouses queries the warehouses edge of a Vendor.
func (c *VendorClient) QueryWarehouses(v *Vendor) *WarehouseQuery {
	query := (&WarehouseClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := v.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vendor.Table, vendor.FieldID, id),
			sqlgraph.To(warehouse.Table, warehouse.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, vendor.WarehousesTable, vendor.WarehousesColumn),
		)
		fromV = sqlgraph.Neighbors(v.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryProducts queries the products edge of a Vendor.
func (c *VendorClient) QueryProducts(v *Vendor) *ProductQuery {
	query := (&ProductClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := v.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vendor.Table, vendor.FieldID, id),
			sqlgraph.To(product.Table, product.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, vendor.ProductsTable, vendor.ProductsColumn),
		)
		fromV = sqlgraph.Neighbors(v.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *VendorClient) mutate(ctx context.Context, m *VendorMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&VendorCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&VendorUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&VendorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&VendorDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Vendor mutation op: %q", m.Op())
	}
}

// WarehouseClient is a client for the Warehouse schema.
type WarehouseClient struct {
	config
}

// NewWarehouseClient returns a client for the Warehouse from the given config.
func NewWarehouseClient(c config) *WarehouseClient {
	return &WarehouseClient{config: c}
}

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

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

// Create returns a builder for creating a Warehouse entity.
func (c *WarehouseClient) Create() *WarehouseCreate {
	mutation := newWarehouseMutation(c.config, OpCreate)
	return &WarehouseCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Warehouse entities.
func (c *WarehouseClient) CreateBulk(builders ...*WarehouseCreate) *WarehouseCreateBulk {
	return &WarehouseCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Warehouse.
func (c *WarehouseClient) Update() *WarehouseUpdate {
	mutation := newWarehouseMutation(c.config, OpUpdate)
	return &WarehouseUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *WarehouseClient) UpdateOne(w *Warehouse) *WarehouseUpdateOne {
	mutation := newWarehouseMutation(c.config, OpUpdateOne, withWarehouse(w))
	return &WarehouseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *WarehouseClient) UpdateOneID(id uuid.UUID) *WarehouseUpdateOne {
	mutation := newWarehouseMutation(c.config, OpUpdateOne, withWarehouseID(id))
	return &WarehouseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Warehouse.
func (c *WarehouseClient) Delete() *WarehouseDelete {
	mutation := newWarehouseMutation(c.config, OpDelete)
	return &WarehouseDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *WarehouseClient) DeleteOne(w *Warehouse) *WarehouseDeleteOne {
	return c.DeleteOneID(w.ID)
}

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

// Query returns a query builder for Warehouse.
func (c *WarehouseClient) Query() *WarehouseQuery {
	return &WarehouseQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeWarehouse},
		inters: c.Interceptors(),
	}
}

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

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

// QueryProducts queries the products edge of a Warehouse.
func (c *WarehouseClient) QueryProducts(w *Warehouse) *ProductQuery {
	query := (&ProductClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := w.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(warehouse.Table, warehouse.FieldID, id),
			sqlgraph.To(product.Table, product.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, warehouse.ProductsTable, warehouse.ProductsColumn),
		)
		fromV = sqlgraph.Neighbors(w.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryVendor queries the vendor edge of a Warehouse.
func (c *WarehouseClient) QueryVendor(w *Warehouse) *VendorQuery {
	query := (&VendorClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := w.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(warehouse.Table, warehouse.FieldID, id),
			sqlgraph.To(vendor.Table, vendor.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, warehouse.VendorTable, warehouse.VendorColumn),
		)
		fromV = sqlgraph.Neighbors(w.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *WarehouseClient) mutate(ctx context.Context, m *WarehouseMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&WarehouseCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&WarehouseUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&WarehouseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&WarehouseDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Warehouse mutation op: %q", m.Op())
	}
}

// WebsiteClient is a client for the Website schema.
type WebsiteClient struct {
	config
}

// NewWebsiteClient returns a client for the Website from the given config.
func NewWebsiteClient(c config) *WebsiteClient {
	return &WebsiteClient{config: c}
}

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

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

// Create returns a builder for creating a Website entity.
func (c *WebsiteClient) Create() *WebsiteCreate {
	mutation := newWebsiteMutation(c.config, OpCreate)
	return &WebsiteCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Website entities.
func (c *WebsiteClient) CreateBulk(builders ...*WebsiteCreate) *WebsiteCreateBulk {
	return &WebsiteCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Website.
func (c *WebsiteClient) Update() *WebsiteUpdate {
	mutation := newWebsiteMutation(c.config, OpUpdate)
	return &WebsiteUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *WebsiteClient) UpdateOne(w *Website) *WebsiteUpdateOne {
	mutation := newWebsiteMutation(c.config, OpUpdateOne, withWebsite(w))
	return &WebsiteUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *WebsiteClient) UpdateOneID(id uuid.UUID) *WebsiteUpdateOne {
	mutation := newWebsiteMutation(c.config, OpUpdateOne, withWebsiteID(id))
	return &WebsiteUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Website.
func (c *WebsiteClient) Delete() *WebsiteDelete {
	mutation := newWebsiteMutation(c.config, OpDelete)
	return &WebsiteDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *WebsiteClient) DeleteOne(w *Website) *WebsiteDeleteOne {
	return c.DeleteOneID(w.ID)
}

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

// Query returns a query builder for Website.
func (c *WebsiteClient) Query() *WebsiteQuery {
	return &WebsiteQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeWebsite},
		inters: c.Interceptors(),
	}
}

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

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

// QueryCompany queries the company edge of a Website.
func (c *WebsiteClient) QueryCompany(w *Website) *CompanyQuery {
	query := (&CompanyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := w.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(website.Table, website.FieldID, id),
			sqlgraph.To(company.Table, company.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, website.CompanyTable, website.CompanyColumn),
		)
		fromV = sqlgraph.Neighbors(w.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCountry queries the country edge of a Website.
func (c *WebsiteClient) QueryCountry(w *Website) *CountryQuery {
	query := (&CountryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := w.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(website.Table, website.FieldID, id),
			sqlgraph.To(country.Table, country.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, website.CountryTable, website.CountryColumn),
		)
		fromV = sqlgraph.Neighbors(w.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

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

func (c *WebsiteClient) mutate(ctx context.Context, m *WebsiteMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&WebsiteCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&WebsiteUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&WebsiteUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&WebsiteDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Website mutation op: %q", m.Op())
	}
}