client.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"log"

	"github.com/mrzack99s/netcoco/ent/migrate"

	"github.com/mrzack99s/netcoco/ent/administrator"
	"github.com/mrzack99s/netcoco/ent/deletedvlanlog"
	"github.com/mrzack99s/netcoco/ent/device"
	"github.com/mrzack99s/netcoco/ent/deviceplatform"
	"github.com/mrzack99s/netcoco/ent/devicetype"
	"github.com/mrzack99s/netcoco/ent/netinterface"
	"github.com/mrzack99s/netcoco/ent/netinterfacemode"
	"github.com/mrzack99s/netcoco/ent/nettopology"
	"github.com/mrzack99s/netcoco/ent/nettopologydevicemap"
	"github.com/mrzack99s/netcoco/ent/vlan"

	"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
	// Administrator is the client for interacting with the Administrator builders.
	Administrator *AdministratorClient
	// DeletedVlanLog is the client for interacting with the DeletedVlanLog builders.
	DeletedVlanLog *DeletedVlanLogClient
	// Device is the client for interacting with the Device builders.
	Device *DeviceClient
	// DevicePlatform is the client for interacting with the DevicePlatform builders.
	DevicePlatform *DevicePlatformClient
	// DeviceType is the client for interacting with the DeviceType builders.
	DeviceType *DeviceTypeClient
	// NetInterface is the client for interacting with the NetInterface builders.
	NetInterface *NetInterfaceClient
	// NetInterfaceMode is the client for interacting with the NetInterfaceMode builders.
	NetInterfaceMode *NetInterfaceModeClient
	// NetTopology is the client for interacting with the NetTopology builders.
	NetTopology *NetTopologyClient
	// NetTopologyDeviceMap is the client for interacting with the NetTopologyDeviceMap builders.
	NetTopologyDeviceMap *NetTopologyDeviceMapClient
	// Vlan is the client for interacting with the Vlan builders.
	Vlan *VlanClient
}

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

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.Administrator = NewAdministratorClient(c.config)
	c.DeletedVlanLog = NewDeletedVlanLogClient(c.config)
	c.Device = NewDeviceClient(c.config)
	c.DevicePlatform = NewDevicePlatformClient(c.config)
	c.DeviceType = NewDeviceTypeClient(c.config)
	c.NetInterface = NewNetInterfaceClient(c.config)
	c.NetInterfaceMode = NewNetInterfaceModeClient(c.config)
	c.NetTopology = NewNetTopologyClient(c.config)
	c.NetTopologyDeviceMap = NewNetTopologyDeviceMapClient(c.config)
	c.Vlan = NewVlanClient(c.config)
}

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

// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, fmt.Errorf("ent: cannot start a transaction within a transaction")
	}
	tx, err := newTx(ctx, c.driver)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:                  ctx,
		config:               cfg,
		Administrator:        NewAdministratorClient(cfg),
		DeletedVlanLog:       NewDeletedVlanLogClient(cfg),
		Device:               NewDeviceClient(cfg),
		DevicePlatform:       NewDevicePlatformClient(cfg),
		DeviceType:           NewDeviceTypeClient(cfg),
		NetInterface:         NewNetInterfaceClient(cfg),
		NetInterfaceMode:     NewNetInterfaceModeClient(cfg),
		NetTopology:          NewNetTopologyClient(cfg),
		NetTopologyDeviceMap: NewNetTopologyDeviceMapClient(cfg),
		Vlan:                 NewVlanClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, fmt.Errorf("ent: cannot start a transaction within a transaction")
	}
	tx, err := c.driver.(interface {
		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
	}).BeginTx(ctx, opts)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = &txDriver{tx: tx, drv: c.driver}
	return &Tx{
		config:               cfg,
		Administrator:        NewAdministratorClient(cfg),
		DeletedVlanLog:       NewDeletedVlanLogClient(cfg),
		Device:               NewDeviceClient(cfg),
		DevicePlatform:       NewDevicePlatformClient(cfg),
		DeviceType:           NewDeviceTypeClient(cfg),
		NetInterface:         NewNetInterfaceClient(cfg),
		NetInterfaceMode:     NewNetInterfaceModeClient(cfg),
		NetTopology:          NewNetTopologyClient(cfg),
		NetTopologyDeviceMap: NewNetTopologyDeviceMapClient(cfg),
		Vlan:                 NewVlanClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		Administrator.
//		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.Administrator.Use(hooks...)
	c.DeletedVlanLog.Use(hooks...)
	c.Device.Use(hooks...)
	c.DevicePlatform.Use(hooks...)
	c.DeviceType.Use(hooks...)
	c.NetInterface.Use(hooks...)
	c.NetInterfaceMode.Use(hooks...)
	c.NetTopology.Use(hooks...)
	c.NetTopologyDeviceMap.Use(hooks...)
	c.Vlan.Use(hooks...)
}

// AdministratorClient is a client for the Administrator schema.
type AdministratorClient struct {
	config
}

// NewAdministratorClient returns a client for the Administrator from the given config.
func NewAdministratorClient(c config) *AdministratorClient {
	return &AdministratorClient{config: c}
}

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

// Create returns a create builder for Administrator.
func (c *AdministratorClient) Create() *AdministratorCreate {
	mutation := newAdministratorMutation(c.config, OpCreate)
	return &AdministratorCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Administrator entities.
func (c *AdministratorClient) CreateBulk(builders ...*AdministratorCreate) *AdministratorCreateBulk {
	return &AdministratorCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Administrator.
func (c *AdministratorClient) Update() *AdministratorUpdate {
	mutation := newAdministratorMutation(c.config, OpUpdate)
	return &AdministratorUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *AdministratorClient) UpdateOne(a *Administrator) *AdministratorUpdateOne {
	mutation := newAdministratorMutation(c.config, OpUpdateOne, withAdministrator(a))
	return &AdministratorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *AdministratorClient) UpdateOneID(id int) *AdministratorUpdateOne {
	mutation := newAdministratorMutation(c.config, OpUpdateOne, withAdministratorID(id))
	return &AdministratorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Administrator.
func (c *AdministratorClient) Delete() *AdministratorDelete {
	mutation := newAdministratorMutation(c.config, OpDelete)
	return &AdministratorDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *AdministratorClient) DeleteOne(a *Administrator) *AdministratorDeleteOne {
	return c.DeleteOneID(a.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *AdministratorClient) DeleteOneID(id int) *AdministratorDeleteOne {
	builder := c.Delete().Where(administrator.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &AdministratorDeleteOne{builder}
}

// Query returns a query builder for Administrator.
func (c *AdministratorClient) Query() *AdministratorQuery {
	return &AdministratorQuery{
		config: c.config,
	}
}

// Get returns a Administrator entity by its id.
func (c *AdministratorClient) Get(ctx context.Context, id int) (*Administrator, error) {
	return c.Query().Where(administrator.ID(id)).Only(ctx)
}

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

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

// DeletedVlanLogClient is a client for the DeletedVlanLog schema.
type DeletedVlanLogClient struct {
	config
}

// NewDeletedVlanLogClient returns a client for the DeletedVlanLog from the given config.
func NewDeletedVlanLogClient(c config) *DeletedVlanLogClient {
	return &DeletedVlanLogClient{config: c}
}

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

// Create returns a create builder for DeletedVlanLog.
func (c *DeletedVlanLogClient) Create() *DeletedVlanLogCreate {
	mutation := newDeletedVlanLogMutation(c.config, OpCreate)
	return &DeletedVlanLogCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DeletedVlanLog entities.
func (c *DeletedVlanLogClient) CreateBulk(builders ...*DeletedVlanLogCreate) *DeletedVlanLogCreateBulk {
	return &DeletedVlanLogCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DeletedVlanLog.
func (c *DeletedVlanLogClient) Update() *DeletedVlanLogUpdate {
	mutation := newDeletedVlanLogMutation(c.config, OpUpdate)
	return &DeletedVlanLogUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeletedVlanLogClient) UpdateOne(dvl *DeletedVlanLog) *DeletedVlanLogUpdateOne {
	mutation := newDeletedVlanLogMutation(c.config, OpUpdateOne, withDeletedVlanLog(dvl))
	return &DeletedVlanLogUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeletedVlanLogClient) UpdateOneID(id int) *DeletedVlanLogUpdateOne {
	mutation := newDeletedVlanLogMutation(c.config, OpUpdateOne, withDeletedVlanLogID(id))
	return &DeletedVlanLogUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DeletedVlanLog.
func (c *DeletedVlanLogClient) Delete() *DeletedVlanLogDelete {
	mutation := newDeletedVlanLogMutation(c.config, OpDelete)
	return &DeletedVlanLogDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeletedVlanLogClient) DeleteOne(dvl *DeletedVlanLog) *DeletedVlanLogDeleteOne {
	return c.DeleteOneID(dvl.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeletedVlanLogClient) DeleteOneID(id int) *DeletedVlanLogDeleteOne {
	builder := c.Delete().Where(deletedvlanlog.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeletedVlanLogDeleteOne{builder}
}

// Query returns a query builder for DeletedVlanLog.
func (c *DeletedVlanLogClient) Query() *DeletedVlanLogQuery {
	return &DeletedVlanLogQuery{
		config: c.config,
	}
}

// Get returns a DeletedVlanLog entity by its id.
func (c *DeletedVlanLogClient) Get(ctx context.Context, id int) (*DeletedVlanLog, error) {
	return c.Query().Where(deletedvlanlog.ID(id)).Only(ctx)
}

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

// QueryOnDevice queries the on_device edge of a DeletedVlanLog.
func (c *DeletedVlanLogClient) QueryOnDevice(dvl *DeletedVlanLog) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := dvl.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deletedvlanlog.Table, deletedvlanlog.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, deletedvlanlog.OnDeviceTable, deletedvlanlog.OnDeviceColumn),
		)
		fromV = sqlgraph.Neighbors(dvl.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// DeviceClient is a client for the Device schema.
type DeviceClient struct {
	config
}

// NewDeviceClient returns a client for the Device from the given config.
func NewDeviceClient(c config) *DeviceClient {
	return &DeviceClient{config: c}
}

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

// Create returns a create builder for Device.
func (c *DeviceClient) Create() *DeviceCreate {
	mutation := newDeviceMutation(c.config, OpCreate)
	return &DeviceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Device entities.
func (c *DeviceClient) CreateBulk(builders ...*DeviceCreate) *DeviceCreateBulk {
	return &DeviceCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Device.
func (c *DeviceClient) Update() *DeviceUpdate {
	mutation := newDeviceMutation(c.config, OpUpdate)
	return &DeviceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeviceClient) UpdateOne(d *Device) *DeviceUpdateOne {
	mutation := newDeviceMutation(c.config, OpUpdateOne, withDevice(d))
	return &DeviceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeviceClient) UpdateOneID(id int) *DeviceUpdateOne {
	mutation := newDeviceMutation(c.config, OpUpdateOne, withDeviceID(id))
	return &DeviceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Device.
func (c *DeviceClient) Delete() *DeviceDelete {
	mutation := newDeviceMutation(c.config, OpDelete)
	return &DeviceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeviceClient) DeleteOne(d *Device) *DeviceDeleteOne {
	return c.DeleteOneID(d.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeviceClient) DeleteOneID(id int) *DeviceDeleteOne {
	builder := c.Delete().Where(device.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeviceDeleteOne{builder}
}

// Query returns a query builder for Device.
func (c *DeviceClient) Query() *DeviceQuery {
	return &DeviceQuery{
		config: c.config,
	}
}

// Get returns a Device entity by its id.
func (c *DeviceClient) Get(ctx context.Context, id int) (*Device, error) {
	return c.Query().Where(device.ID(id)).Only(ctx)
}

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

// QueryInType queries the in_type edge of a Device.
func (c *DeviceClient) QueryInType(d *Device) *DeviceTypeQuery {
	query := &DeviceTypeQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(devicetype.Table, devicetype.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, device.InTypeTable, device.InTypeColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryInPlatform queries the in_platform edge of a Device.
func (c *DeviceClient) QueryInPlatform(d *Device) *DevicePlatformQuery {
	query := &DevicePlatformQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(deviceplatform.Table, deviceplatform.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, device.InPlatformTable, device.InPlatformColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryInterfaces queries the interfaces edge of a Device.
func (c *DeviceClient) QueryInterfaces(d *Device) *NetInterfaceQuery {
	query := &NetInterfaceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(netinterface.Table, netinterface.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, device.InterfacesTable, device.InterfacesColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryInTopology queries the in_topology edge of a Device.
func (c *DeviceClient) QueryInTopology(d *Device) *NetTopologyDeviceMapQuery {
	query := &NetTopologyDeviceMapQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(nettopologydevicemap.Table, nettopologydevicemap.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, device.InTopologyTable, device.InTopologyColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryStoreVlans queries the store_vlans edge of a Device.
func (c *DeviceClient) QueryStoreVlans(d *Device) *VlanQuery {
	query := &VlanQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(vlan.Table, vlan.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, device.StoreVlansTable, device.StoreVlansPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDeletedVlans queries the deleted_vlans edge of a Device.
func (c *DeviceClient) QueryDeletedVlans(d *Device) *DeletedVlanLogQuery {
	query := &DeletedVlanLogQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := d.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(device.Table, device.FieldID, id),
			sqlgraph.To(deletedvlanlog.Table, deletedvlanlog.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, device.DeletedVlansTable, device.DeletedVlansColumn),
		)
		fromV = sqlgraph.Neighbors(d.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// DevicePlatformClient is a client for the DevicePlatform schema.
type DevicePlatformClient struct {
	config
}

// NewDevicePlatformClient returns a client for the DevicePlatform from the given config.
func NewDevicePlatformClient(c config) *DevicePlatformClient {
	return &DevicePlatformClient{config: c}
}

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

// Create returns a create builder for DevicePlatform.
func (c *DevicePlatformClient) Create() *DevicePlatformCreate {
	mutation := newDevicePlatformMutation(c.config, OpCreate)
	return &DevicePlatformCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DevicePlatform entities.
func (c *DevicePlatformClient) CreateBulk(builders ...*DevicePlatformCreate) *DevicePlatformCreateBulk {
	return &DevicePlatformCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DevicePlatform.
func (c *DevicePlatformClient) Update() *DevicePlatformUpdate {
	mutation := newDevicePlatformMutation(c.config, OpUpdate)
	return &DevicePlatformUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DevicePlatformClient) UpdateOne(dp *DevicePlatform) *DevicePlatformUpdateOne {
	mutation := newDevicePlatformMutation(c.config, OpUpdateOne, withDevicePlatform(dp))
	return &DevicePlatformUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DevicePlatformClient) UpdateOneID(id int) *DevicePlatformUpdateOne {
	mutation := newDevicePlatformMutation(c.config, OpUpdateOne, withDevicePlatformID(id))
	return &DevicePlatformUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DevicePlatform.
func (c *DevicePlatformClient) Delete() *DevicePlatformDelete {
	mutation := newDevicePlatformMutation(c.config, OpDelete)
	return &DevicePlatformDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DevicePlatformClient) DeleteOne(dp *DevicePlatform) *DevicePlatformDeleteOne {
	return c.DeleteOneID(dp.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DevicePlatformClient) DeleteOneID(id int) *DevicePlatformDeleteOne {
	builder := c.Delete().Where(deviceplatform.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DevicePlatformDeleteOne{builder}
}

// Query returns a query builder for DevicePlatform.
func (c *DevicePlatformClient) Query() *DevicePlatformQuery {
	return &DevicePlatformQuery{
		config: c.config,
	}
}

// Get returns a DevicePlatform entity by its id.
func (c *DevicePlatformClient) Get(ctx context.Context, id int) (*DevicePlatform, error) {
	return c.Query().Where(deviceplatform.ID(id)).Only(ctx)
}

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

// QueryPlatforms queries the platforms edge of a DevicePlatform.
func (c *DevicePlatformClient) QueryPlatforms(dp *DevicePlatform) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := dp.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(deviceplatform.Table, deviceplatform.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, deviceplatform.PlatformsTable, deviceplatform.PlatformsColumn),
		)
		fromV = sqlgraph.Neighbors(dp.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// DeviceTypeClient is a client for the DeviceType schema.
type DeviceTypeClient struct {
	config
}

// NewDeviceTypeClient returns a client for the DeviceType from the given config.
func NewDeviceTypeClient(c config) *DeviceTypeClient {
	return &DeviceTypeClient{config: c}
}

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

// Create returns a create builder for DeviceType.
func (c *DeviceTypeClient) Create() *DeviceTypeCreate {
	mutation := newDeviceTypeMutation(c.config, OpCreate)
	return &DeviceTypeCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of DeviceType entities.
func (c *DeviceTypeClient) CreateBulk(builders ...*DeviceTypeCreate) *DeviceTypeCreateBulk {
	return &DeviceTypeCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for DeviceType.
func (c *DeviceTypeClient) Update() *DeviceTypeUpdate {
	mutation := newDeviceTypeMutation(c.config, OpUpdate)
	return &DeviceTypeUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *DeviceTypeClient) UpdateOne(dt *DeviceType) *DeviceTypeUpdateOne {
	mutation := newDeviceTypeMutation(c.config, OpUpdateOne, withDeviceType(dt))
	return &DeviceTypeUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *DeviceTypeClient) UpdateOneID(id int) *DeviceTypeUpdateOne {
	mutation := newDeviceTypeMutation(c.config, OpUpdateOne, withDeviceTypeID(id))
	return &DeviceTypeUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for DeviceType.
func (c *DeviceTypeClient) Delete() *DeviceTypeDelete {
	mutation := newDeviceTypeMutation(c.config, OpDelete)
	return &DeviceTypeDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *DeviceTypeClient) DeleteOne(dt *DeviceType) *DeviceTypeDeleteOne {
	return c.DeleteOneID(dt.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *DeviceTypeClient) DeleteOneID(id int) *DeviceTypeDeleteOne {
	builder := c.Delete().Where(devicetype.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &DeviceTypeDeleteOne{builder}
}

// Query returns a query builder for DeviceType.
func (c *DeviceTypeClient) Query() *DeviceTypeQuery {
	return &DeviceTypeQuery{
		config: c.config,
	}
}

// Get returns a DeviceType entity by its id.
func (c *DeviceTypeClient) Get(ctx context.Context, id int) (*DeviceType, error) {
	return c.Query().Where(devicetype.ID(id)).Only(ctx)
}

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

// QueryTypes queries the types edge of a DeviceType.
func (c *DeviceTypeClient) QueryTypes(dt *DeviceType) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := dt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(devicetype.Table, devicetype.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, devicetype.TypesTable, devicetype.TypesColumn),
		)
		fromV = sqlgraph.Neighbors(dt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// NetInterfaceClient is a client for the NetInterface schema.
type NetInterfaceClient struct {
	config
}

// NewNetInterfaceClient returns a client for the NetInterface from the given config.
func NewNetInterfaceClient(c config) *NetInterfaceClient {
	return &NetInterfaceClient{config: c}
}

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

// Create returns a create builder for NetInterface.
func (c *NetInterfaceClient) Create() *NetInterfaceCreate {
	mutation := newNetInterfaceMutation(c.config, OpCreate)
	return &NetInterfaceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of NetInterface entities.
func (c *NetInterfaceClient) CreateBulk(builders ...*NetInterfaceCreate) *NetInterfaceCreateBulk {
	return &NetInterfaceCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for NetInterface.
func (c *NetInterfaceClient) Update() *NetInterfaceUpdate {
	mutation := newNetInterfaceMutation(c.config, OpUpdate)
	return &NetInterfaceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *NetInterfaceClient) UpdateOne(ni *NetInterface) *NetInterfaceUpdateOne {
	mutation := newNetInterfaceMutation(c.config, OpUpdateOne, withNetInterface(ni))
	return &NetInterfaceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *NetInterfaceClient) UpdateOneID(id int) *NetInterfaceUpdateOne {
	mutation := newNetInterfaceMutation(c.config, OpUpdateOne, withNetInterfaceID(id))
	return &NetInterfaceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for NetInterface.
func (c *NetInterfaceClient) Delete() *NetInterfaceDelete {
	mutation := newNetInterfaceMutation(c.config, OpDelete)
	return &NetInterfaceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *NetInterfaceClient) DeleteOne(ni *NetInterface) *NetInterfaceDeleteOne {
	return c.DeleteOneID(ni.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *NetInterfaceClient) DeleteOneID(id int) *NetInterfaceDeleteOne {
	builder := c.Delete().Where(netinterface.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &NetInterfaceDeleteOne{builder}
}

// Query returns a query builder for NetInterface.
func (c *NetInterfaceClient) Query() *NetInterfaceQuery {
	return &NetInterfaceQuery{
		config: c.config,
	}
}

// Get returns a NetInterface entity by its id.
func (c *NetInterfaceClient) Get(ctx context.Context, id int) (*NetInterface, error) {
	return c.Query().Where(netinterface.ID(id)).Only(ctx)
}

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

// QueryOnDevice queries the on_device edge of a NetInterface.
func (c *NetInterfaceClient) QueryOnDevice(ni *NetInterface) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ni.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(netinterface.Table, netinterface.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, netinterface.OnDeviceTable, netinterface.OnDeviceColumn),
		)
		fromV = sqlgraph.Neighbors(ni.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryMode queries the mode edge of a NetInterface.
func (c *NetInterfaceClient) QueryMode(ni *NetInterface) *NetInterfaceModeQuery {
	query := &NetInterfaceModeQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ni.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(netinterface.Table, netinterface.FieldID, id),
			sqlgraph.To(netinterfacemode.Table, netinterfacemode.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, netinterface.ModeTable, netinterface.ModeColumn),
		)
		fromV = sqlgraph.Neighbors(ni.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryHaveVlans queries the have_vlans edge of a NetInterface.
func (c *NetInterfaceClient) QueryHaveVlans(ni *NetInterface) *VlanQuery {
	query := &VlanQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ni.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(netinterface.Table, netinterface.FieldID, id),
			sqlgraph.To(vlan.Table, vlan.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, netinterface.HaveVlansTable, netinterface.HaveVlansPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(ni.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryNativeOnVlan queries the native_on_vlan edge of a NetInterface.
func (c *NetInterfaceClient) QueryNativeOnVlan(ni *NetInterface) *VlanQuery {
	query := &VlanQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ni.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(netinterface.Table, netinterface.FieldID, id),
			sqlgraph.To(vlan.Table, vlan.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, netinterface.NativeOnVlanTable, netinterface.NativeOnVlanColumn),
		)
		fromV = sqlgraph.Neighbors(ni.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// NetInterfaceModeClient is a client for the NetInterfaceMode schema.
type NetInterfaceModeClient struct {
	config
}

// NewNetInterfaceModeClient returns a client for the NetInterfaceMode from the given config.
func NewNetInterfaceModeClient(c config) *NetInterfaceModeClient {
	return &NetInterfaceModeClient{config: c}
}

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

// Create returns a create builder for NetInterfaceMode.
func (c *NetInterfaceModeClient) Create() *NetInterfaceModeCreate {
	mutation := newNetInterfaceModeMutation(c.config, OpCreate)
	return &NetInterfaceModeCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of NetInterfaceMode entities.
func (c *NetInterfaceModeClient) CreateBulk(builders ...*NetInterfaceModeCreate) *NetInterfaceModeCreateBulk {
	return &NetInterfaceModeCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for NetInterfaceMode.
func (c *NetInterfaceModeClient) Update() *NetInterfaceModeUpdate {
	mutation := newNetInterfaceModeMutation(c.config, OpUpdate)
	return &NetInterfaceModeUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *NetInterfaceModeClient) UpdateOne(nim *NetInterfaceMode) *NetInterfaceModeUpdateOne {
	mutation := newNetInterfaceModeMutation(c.config, OpUpdateOne, withNetInterfaceMode(nim))
	return &NetInterfaceModeUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *NetInterfaceModeClient) UpdateOneID(id int) *NetInterfaceModeUpdateOne {
	mutation := newNetInterfaceModeMutation(c.config, OpUpdateOne, withNetInterfaceModeID(id))
	return &NetInterfaceModeUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for NetInterfaceMode.
func (c *NetInterfaceModeClient) Delete() *NetInterfaceModeDelete {
	mutation := newNetInterfaceModeMutation(c.config, OpDelete)
	return &NetInterfaceModeDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *NetInterfaceModeClient) DeleteOne(nim *NetInterfaceMode) *NetInterfaceModeDeleteOne {
	return c.DeleteOneID(nim.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *NetInterfaceModeClient) DeleteOneID(id int) *NetInterfaceModeDeleteOne {
	builder := c.Delete().Where(netinterfacemode.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &NetInterfaceModeDeleteOne{builder}
}

// Query returns a query builder for NetInterfaceMode.
func (c *NetInterfaceModeClient) Query() *NetInterfaceModeQuery {
	return &NetInterfaceModeQuery{
		config: c.config,
	}
}

// Get returns a NetInterfaceMode entity by its id.
func (c *NetInterfaceModeClient) Get(ctx context.Context, id int) (*NetInterfaceMode, error) {
	return c.Query().Where(netinterfacemode.ID(id)).Only(ctx)
}

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

// QueryModes queries the modes edge of a NetInterfaceMode.
func (c *NetInterfaceModeClient) QueryModes(nim *NetInterfaceMode) *NetInterfaceQuery {
	query := &NetInterfaceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := nim.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(netinterfacemode.Table, netinterfacemode.FieldID, id),
			sqlgraph.To(netinterface.Table, netinterface.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, netinterfacemode.ModesTable, netinterfacemode.ModesColumn),
		)
		fromV = sqlgraph.Neighbors(nim.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// NetTopologyClient is a client for the NetTopology schema.
type NetTopologyClient struct {
	config
}

// NewNetTopologyClient returns a client for the NetTopology from the given config.
func NewNetTopologyClient(c config) *NetTopologyClient {
	return &NetTopologyClient{config: c}
}

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

// Create returns a create builder for NetTopology.
func (c *NetTopologyClient) Create() *NetTopologyCreate {
	mutation := newNetTopologyMutation(c.config, OpCreate)
	return &NetTopologyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of NetTopology entities.
func (c *NetTopologyClient) CreateBulk(builders ...*NetTopologyCreate) *NetTopologyCreateBulk {
	return &NetTopologyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for NetTopology.
func (c *NetTopologyClient) Update() *NetTopologyUpdate {
	mutation := newNetTopologyMutation(c.config, OpUpdate)
	return &NetTopologyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *NetTopologyClient) UpdateOne(nt *NetTopology) *NetTopologyUpdateOne {
	mutation := newNetTopologyMutation(c.config, OpUpdateOne, withNetTopology(nt))
	return &NetTopologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *NetTopologyClient) UpdateOneID(id int) *NetTopologyUpdateOne {
	mutation := newNetTopologyMutation(c.config, OpUpdateOne, withNetTopologyID(id))
	return &NetTopologyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for NetTopology.
func (c *NetTopologyClient) Delete() *NetTopologyDelete {
	mutation := newNetTopologyMutation(c.config, OpDelete)
	return &NetTopologyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *NetTopologyClient) DeleteOne(nt *NetTopology) *NetTopologyDeleteOne {
	return c.DeleteOneID(nt.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *NetTopologyClient) DeleteOneID(id int) *NetTopologyDeleteOne {
	builder := c.Delete().Where(nettopology.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &NetTopologyDeleteOne{builder}
}

// Query returns a query builder for NetTopology.
func (c *NetTopologyClient) Query() *NetTopologyQuery {
	return &NetTopologyQuery{
		config: c.config,
	}
}

// Get returns a NetTopology entity by its id.
func (c *NetTopologyClient) Get(ctx context.Context, id int) (*NetTopology, error) {
	return c.Query().Where(nettopology.ID(id)).Only(ctx)
}

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

// QueryTopology queries the topology edge of a NetTopology.
func (c *NetTopologyClient) QueryTopology(nt *NetTopology) *NetTopologyDeviceMapQuery {
	query := &NetTopologyDeviceMapQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := nt.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(nettopology.Table, nettopology.FieldID, id),
			sqlgraph.To(nettopologydevicemap.Table, nettopologydevicemap.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, nettopology.TopologyTable, nettopology.TopologyColumn),
		)
		fromV = sqlgraph.Neighbors(nt.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// NetTopologyDeviceMapClient is a client for the NetTopologyDeviceMap schema.
type NetTopologyDeviceMapClient struct {
	config
}

// NewNetTopologyDeviceMapClient returns a client for the NetTopologyDeviceMap from the given config.
func NewNetTopologyDeviceMapClient(c config) *NetTopologyDeviceMapClient {
	return &NetTopologyDeviceMapClient{config: c}
}

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

// Create returns a create builder for NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) Create() *NetTopologyDeviceMapCreate {
	mutation := newNetTopologyDeviceMapMutation(c.config, OpCreate)
	return &NetTopologyDeviceMapCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of NetTopologyDeviceMap entities.
func (c *NetTopologyDeviceMapClient) CreateBulk(builders ...*NetTopologyDeviceMapCreate) *NetTopologyDeviceMapCreateBulk {
	return &NetTopologyDeviceMapCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) Update() *NetTopologyDeviceMapUpdate {
	mutation := newNetTopologyDeviceMapMutation(c.config, OpUpdate)
	return &NetTopologyDeviceMapUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *NetTopologyDeviceMapClient) UpdateOne(ntdm *NetTopologyDeviceMap) *NetTopologyDeviceMapUpdateOne {
	mutation := newNetTopologyDeviceMapMutation(c.config, OpUpdateOne, withNetTopologyDeviceMap(ntdm))
	return &NetTopologyDeviceMapUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *NetTopologyDeviceMapClient) UpdateOneID(id int) *NetTopologyDeviceMapUpdateOne {
	mutation := newNetTopologyDeviceMapMutation(c.config, OpUpdateOne, withNetTopologyDeviceMapID(id))
	return &NetTopologyDeviceMapUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) Delete() *NetTopologyDeviceMapDelete {
	mutation := newNetTopologyDeviceMapMutation(c.config, OpDelete)
	return &NetTopologyDeviceMapDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *NetTopologyDeviceMapClient) DeleteOne(ntdm *NetTopologyDeviceMap) *NetTopologyDeviceMapDeleteOne {
	return c.DeleteOneID(ntdm.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *NetTopologyDeviceMapClient) DeleteOneID(id int) *NetTopologyDeviceMapDeleteOne {
	builder := c.Delete().Where(nettopologydevicemap.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &NetTopologyDeviceMapDeleteOne{builder}
}

// Query returns a query builder for NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) Query() *NetTopologyDeviceMapQuery {
	return &NetTopologyDeviceMapQuery{
		config: c.config,
	}
}

// Get returns a NetTopologyDeviceMap entity by its id.
func (c *NetTopologyDeviceMapClient) Get(ctx context.Context, id int) (*NetTopologyDeviceMap, error) {
	return c.Query().Where(nettopologydevicemap.ID(id)).Only(ctx)
}

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

// QueryOnTopology queries the on_topology edge of a NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) QueryOnTopology(ntdm *NetTopologyDeviceMap) *NetTopologyQuery {
	query := &NetTopologyQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ntdm.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(nettopologydevicemap.Table, nettopologydevicemap.FieldID, id),
			sqlgraph.To(nettopology.Table, nettopology.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, nettopologydevicemap.OnTopologyTable, nettopologydevicemap.OnTopologyColumn),
		)
		fromV = sqlgraph.Neighbors(ntdm.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryDevice queries the device edge of a NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) QueryDevice(ntdm *NetTopologyDeviceMap) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ntdm.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(nettopologydevicemap.Table, nettopologydevicemap.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, nettopologydevicemap.DeviceTable, nettopologydevicemap.DeviceColumn),
		)
		fromV = sqlgraph.Neighbors(ntdm.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryEdge queries the edge edge of a NetTopologyDeviceMap.
func (c *NetTopologyDeviceMapClient) QueryEdge(ntdm *NetTopologyDeviceMap) *NetTopologyDeviceMapQuery {
	query := &NetTopologyDeviceMapQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := ntdm.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(nettopologydevicemap.Table, nettopologydevicemap.FieldID, id),
			sqlgraph.To(nettopologydevicemap.Table, nettopologydevicemap.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, nettopologydevicemap.EdgeTable, nettopologydevicemap.EdgePrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(ntdm.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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

// VlanClient is a client for the Vlan schema.
type VlanClient struct {
	config
}

// NewVlanClient returns a client for the Vlan from the given config.
func NewVlanClient(c config) *VlanClient {
	return &VlanClient{config: c}
}

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

// Create returns a create builder for Vlan.
func (c *VlanClient) Create() *VlanCreate {
	mutation := newVlanMutation(c.config, OpCreate)
	return &VlanCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Vlan entities.
func (c *VlanClient) CreateBulk(builders ...*VlanCreate) *VlanCreateBulk {
	return &VlanCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Vlan.
func (c *VlanClient) Update() *VlanUpdate {
	mutation := newVlanMutation(c.config, OpUpdate)
	return &VlanUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *VlanClient) UpdateOne(v *Vlan) *VlanUpdateOne {
	mutation := newVlanMutation(c.config, OpUpdateOne, withVlan(v))
	return &VlanUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *VlanClient) UpdateOneID(id int) *VlanUpdateOne {
	mutation := newVlanMutation(c.config, OpUpdateOne, withVlanID(id))
	return &VlanUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Vlan.
func (c *VlanClient) Delete() *VlanDelete {
	mutation := newVlanMutation(c.config, OpDelete)
	return &VlanDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a delete builder for the given entity.
func (c *VlanClient) DeleteOne(v *Vlan) *VlanDeleteOne {
	return c.DeleteOneID(v.ID)
}

// DeleteOneID returns a delete builder for the given id.
func (c *VlanClient) DeleteOneID(id int) *VlanDeleteOne {
	builder := c.Delete().Where(vlan.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &VlanDeleteOne{builder}
}

// Query returns a query builder for Vlan.
func (c *VlanClient) Query() *VlanQuery {
	return &VlanQuery{
		config: c.config,
	}
}

// Get returns a Vlan entity by its id.
func (c *VlanClient) Get(ctx context.Context, id int) (*Vlan, error) {
	return c.Query().Where(vlan.ID(id)).Only(ctx)
}

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

// QueryVlans queries the vlans edge of a Vlan.
func (c *VlanClient) QueryVlans(v *Vlan) *NetInterfaceQuery {
	query := &NetInterfaceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := v.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vlan.Table, vlan.FieldID, id),
			sqlgraph.To(netinterface.Table, netinterface.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, vlan.VlansTable, vlan.VlansPrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(v.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryNativeVlan queries the native_vlan edge of a Vlan.
func (c *VlanClient) QueryNativeVlan(v *Vlan) *NetInterfaceQuery {
	query := &NetInterfaceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := v.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vlan.Table, vlan.FieldID, id),
			sqlgraph.To(netinterface.Table, netinterface.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, vlan.NativeVlanTable, vlan.NativeVlanColumn),
		)
		fromV = sqlgraph.Neighbors(v.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryOnDevice queries the on_device edge of a Vlan.
func (c *VlanClient) QueryOnDevice(v *Vlan) *DeviceQuery {
	query := &DeviceQuery{config: c.config}
	query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
		id := v.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(vlan.Table, vlan.FieldID, id),
			sqlgraph.To(device.Table, device.FieldID),
			sqlgraph.Edge(sqlgraph.M2M, true, vlan.OnDeviceTable, vlan.OnDevicePrimaryKey...),
		)
		fromV = sqlgraph.Neighbors(v.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

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