mutation.go

// Code generated by entc, DO NOT EDIT.

package ent

import (
	"context"
	"fmt"
	"sync"
	"time"

	"github.com/tmc/moderncrud/ent/predicate"
	"github.com/tmc/moderncrud/ent/widget"
	"github.com/tmc/moderncrud/ent/widgettype"

	"entgo.io/ent"
)

const (
	// Operation types.
	OpCreate    = ent.OpCreate
	OpDelete    = ent.OpDelete
	OpDeleteOne = ent.OpDeleteOne
	OpUpdate    = ent.OpUpdate
	OpUpdateOne = ent.OpUpdateOne

	// Node types.
	TypeWidget     = "Widget"
	TypeWidgetType = "WidgetType"
)

// WidgetMutation represents an operation that mutates the Widget nodes in the graph.
type WidgetMutation struct {
	config
	op            Op
	typ           string
	id            *int
	note          *string
	created_at    *time.Time
	status        *widget.Status
	priority      *int
	addpriority   *int
	clearedFields map[string]struct{}
	_type         *int
	cleared_type  bool
	done          bool
	oldValue      func(context.Context) (*Widget, error)
	predicates    []predicate.Widget
}

var _ ent.Mutation = (*WidgetMutation)(nil)

// widgetOption allows management of the mutation configuration using functional options.
type widgetOption func(*WidgetMutation)

// newWidgetMutation creates new mutation for the Widget entity.
func newWidgetMutation(c config, op Op, opts ...widgetOption) *WidgetMutation {
	m := &WidgetMutation{
		config:        c,
		op:            op,
		typ:           TypeWidget,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withWidgetID sets the ID field of the mutation.
func withWidgetID(id int) widgetOption {
	return func(m *WidgetMutation) {
		var (
			err   error
			once  sync.Once
			value *Widget
		)
		m.oldValue = func(ctx context.Context) (*Widget, error) {
			once.Do(func() {
				if m.done {
					err = fmt.Errorf("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().Widget.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withWidget sets the old Widget of the mutation.
func withWidget(node *Widget) widgetOption {
	return func(m *WidgetMutation) {
		m.oldValue = func(context.Context) (*Widget, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m WidgetMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m WidgetMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, fmt.Errorf("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *WidgetMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// SetNote sets the "note" field.
func (m *WidgetMutation) SetNote(s string) {
	m.note = &s
}

// Note returns the value of the "note" field in the mutation.
func (m *WidgetMutation) Note() (r string, exists bool) {
	v := m.note
	if v == nil {
		return
	}
	return *v, true
}

// OldNote returns the old "note" field's value of the Widget entity.
// If the Widget object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WidgetMutation) OldNote(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldNote is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldNote requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNote: %w", err)
	}
	return oldValue.Note, nil
}

// ResetNote resets all changes to the "note" field.
func (m *WidgetMutation) ResetNote() {
	m.note = nil
}

// SetCreatedAt sets the "created_at" field.
func (m *WidgetMutation) SetCreatedAt(t time.Time) {
	m.created_at = &t
}

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WidgetMutation) CreatedAt() (r time.Time, exists bool) {
	v := m.created_at
	if v == nil {
		return
	}
	return *v, true
}

// OldCreatedAt returns the old "created_at" field's value of the Widget entity.
// If the Widget object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WidgetMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldCreatedAt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
	}
	return oldValue.CreatedAt, nil
}

// ResetCreatedAt resets all changes to the "created_at" field.
func (m *WidgetMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetStatus sets the "status" field.
func (m *WidgetMutation) SetStatus(w widget.Status) {
	m.status = &w
}

// Status returns the value of the "status" field in the mutation.
func (m *WidgetMutation) Status() (r widget.Status, exists bool) {
	v := m.status
	if v == nil {
		return
	}
	return *v, true
}

// OldStatus returns the old "status" field's value of the Widget entity.
// If the Widget object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WidgetMutation) OldStatus(ctx context.Context) (v widget.Status, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldStatus is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldStatus requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStatus: %w", err)
	}
	return oldValue.Status, nil
}

// ResetStatus resets all changes to the "status" field.
func (m *WidgetMutation) ResetStatus() {
	m.status = nil
}

// SetPriority sets the "priority" field.
func (m *WidgetMutation) SetPriority(i int) {
	m.priority = &i
	m.addpriority = nil
}

// Priority returns the value of the "priority" field in the mutation.
func (m *WidgetMutation) Priority() (r int, exists bool) {
	v := m.priority
	if v == nil {
		return
	}
	return *v, true
}

// OldPriority returns the old "priority" field's value of the Widget entity.
// If the Widget object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WidgetMutation) OldPriority(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldPriority is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldPriority requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldPriority: %w", err)
	}
	return oldValue.Priority, nil
}

// AddPriority adds i to the "priority" field.
func (m *WidgetMutation) AddPriority(i int) {
	if m.addpriority != nil {
		*m.addpriority += i
	} else {
		m.addpriority = &i
	}
}

// AddedPriority returns the value that was added to the "priority" field in this mutation.
func (m *WidgetMutation) AddedPriority() (r int, exists bool) {
	v := m.addpriority
	if v == nil {
		return
	}
	return *v, true
}

// ResetPriority resets all changes to the "priority" field.
func (m *WidgetMutation) ResetPriority() {
	m.priority = nil
	m.addpriority = nil
}

// SetTypeID sets the "type" edge to the WidgetType entity by id.
func (m *WidgetMutation) SetTypeID(id int) {
	m._type = &id
}

// ClearType clears the "type" edge to the WidgetType entity.
func (m *WidgetMutation) ClearType() {
	m.cleared_type = true
}

// TypeCleared reports if the "type" edge to the WidgetType entity was cleared.
func (m *WidgetMutation) TypeCleared() bool {
	return m.cleared_type
}

// TypeID returns the "type" edge ID in the mutation.
func (m *WidgetMutation) TypeID() (id int, exists bool) {
	if m._type != nil {
		return *m._type, true
	}
	return
}

// TypeIDs returns the "type" edge IDs in the mutation.
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
// TypeID instead. It exists only for internal usage by the builders.
func (m *WidgetMutation) TypeIDs() (ids []int) {
	if id := m._type; id != nil {
		ids = append(ids, *id)
	}
	return
}

// ResetType resets all changes to the "type" edge.
func (m *WidgetMutation) ResetType() {
	m._type = nil
	m.cleared_type = false
}

// Where appends a list predicates to the WidgetMutation builder.
func (m *WidgetMutation) Where(ps ...predicate.Widget) {
	m.predicates = append(m.predicates, ps...)
}

// Op returns the operation name.
func (m *WidgetMutation) Op() Op {
	return m.op
}

// Type returns the node type of this mutation (Widget).
func (m *WidgetMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *WidgetMutation) Fields() []string {
	fields := make([]string, 0, 4)
	if m.note != nil {
		fields = append(fields, widget.FieldNote)
	}
	if m.created_at != nil {
		fields = append(fields, widget.FieldCreatedAt)
	}
	if m.status != nil {
		fields = append(fields, widget.FieldStatus)
	}
	if m.priority != nil {
		fields = append(fields, widget.FieldPriority)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *WidgetMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case widget.FieldNote:
		return m.Note()
	case widget.FieldCreatedAt:
		return m.CreatedAt()
	case widget.FieldStatus:
		return m.Status()
	case widget.FieldPriority:
		return m.Priority()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *WidgetMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case widget.FieldNote:
		return m.OldNote(ctx)
	case widget.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case widget.FieldStatus:
		return m.OldStatus(ctx)
	case widget.FieldPriority:
		return m.OldPriority(ctx)
	}
	return nil, fmt.Errorf("unknown Widget field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *WidgetMutation) SetField(name string, value ent.Value) error {
	switch name {
	case widget.FieldNote:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNote(v)
		return nil
	case widget.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	case widget.FieldStatus:
		v, ok := value.(widget.Status)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStatus(v)
		return nil
	case widget.FieldPriority:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetPriority(v)
		return nil
	}
	return fmt.Errorf("unknown Widget field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WidgetMutation) AddedFields() []string {
	var fields []string
	if m.addpriority != nil {
		fields = append(fields, widget.FieldPriority)
	}
	return fields
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *WidgetMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case widget.FieldPriority:
		return m.AddedPriority()
	}
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *WidgetMutation) AddField(name string, value ent.Value) error {
	switch name {
	case widget.FieldPriority:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddPriority(v)
		return nil
	}
	return fmt.Errorf("unknown Widget numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WidgetMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WidgetMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *WidgetMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Widget nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *WidgetMutation) ResetField(name string) error {
	switch name {
	case widget.FieldNote:
		m.ResetNote()
		return nil
	case widget.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case widget.FieldStatus:
		m.ResetStatus()
		return nil
	case widget.FieldPriority:
		m.ResetPriority()
		return nil
	}
	return fmt.Errorf("unknown Widget field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *WidgetMutation) AddedEdges() []string {
	edges := make([]string, 0, 1)
	if m._type != nil {
		edges = append(edges, widget.EdgeType)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WidgetMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case widget.EdgeType:
		if id := m._type; id != nil {
			return []ent.Value{*id}
		}
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *WidgetMutation) RemovedEdges() []string {
	edges := make([]string, 0, 1)
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *WidgetMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *WidgetMutation) ClearedEdges() []string {
	edges := make([]string, 0, 1)
	if m.cleared_type {
		edges = append(edges, widget.EdgeType)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WidgetMutation) EdgeCleared(name string) bool {
	switch name {
	case widget.EdgeType:
		return m.cleared_type
	}
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *WidgetMutation) ClearEdge(name string) error {
	switch name {
	case widget.EdgeType:
		m.ClearType()
		return nil
	}
	return fmt.Errorf("unknown Widget unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *WidgetMutation) ResetEdge(name string) error {
	switch name {
	case widget.EdgeType:
		m.ResetType()
		return nil
	}
	return fmt.Errorf("unknown Widget edge %s", name)
}

// WidgetTypeMutation represents an operation that mutates the WidgetType nodes in the graph.
type WidgetTypeMutation struct {
	config
	op            Op
	typ           string
	id            *int
	name          *string
	clearedFields map[string]struct{}
	done          bool
	oldValue      func(context.Context) (*WidgetType, error)
	predicates    []predicate.WidgetType
}

var _ ent.Mutation = (*WidgetTypeMutation)(nil)

// widgettypeOption allows management of the mutation configuration using functional options.
type widgettypeOption func(*WidgetTypeMutation)

// newWidgetTypeMutation creates new mutation for the WidgetType entity.
func newWidgetTypeMutation(c config, op Op, opts ...widgettypeOption) *WidgetTypeMutation {
	m := &WidgetTypeMutation{
		config:        c,
		op:            op,
		typ:           TypeWidgetType,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withWidgetTypeID sets the ID field of the mutation.
func withWidgetTypeID(id int) widgettypeOption {
	return func(m *WidgetTypeMutation) {
		var (
			err   error
			once  sync.Once
			value *WidgetType
		)
		m.oldValue = func(ctx context.Context) (*WidgetType, error) {
			once.Do(func() {
				if m.done {
					err = fmt.Errorf("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().WidgetType.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withWidgetType sets the old WidgetType of the mutation.
func withWidgetType(node *WidgetType) widgettypeOption {
	return func(m *WidgetTypeMutation) {
		m.oldValue = func(context.Context) (*WidgetType, error) {
			return node, nil
		}
		m.id = &node.ID
	}
}

// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m WidgetTypeMutation) Client() *Client {
	client := &Client{config: m.config}
	client.init()
	return client
}

// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m WidgetTypeMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, fmt.Errorf("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *WidgetTypeMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// SetName sets the "name" field.
func (m *WidgetTypeMutation) SetName(s string) {
	m.name = &s
}

// Name returns the value of the "name" field in the mutation.
func (m *WidgetTypeMutation) Name() (r string, exists bool) {
	v := m.name
	if v == nil {
		return
	}
	return *v, true
}

// OldName returns the old "name" field's value of the WidgetType entity.
// If the WidgetType object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *WidgetTypeMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, fmt.Errorf("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, fmt.Errorf("OldName requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldName: %w", err)
	}
	return oldValue.Name, nil
}

// ResetName resets all changes to the "name" field.
func (m *WidgetTypeMutation) ResetName() {
	m.name = nil
}

// Where appends a list predicates to the WidgetTypeMutation builder.
func (m *WidgetTypeMutation) Where(ps ...predicate.WidgetType) {
	m.predicates = append(m.predicates, ps...)
}

// Op returns the operation name.
func (m *WidgetTypeMutation) Op() Op {
	return m.op
}

// Type returns the node type of this mutation (WidgetType).
func (m *WidgetTypeMutation) Type() string {
	return m.typ
}

// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *WidgetTypeMutation) Fields() []string {
	fields := make([]string, 0, 1)
	if m.name != nil {
		fields = append(fields, widgettype.FieldName)
	}
	return fields
}

// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *WidgetTypeMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case widgettype.FieldName:
		return m.Name()
	}
	return nil, false
}

// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *WidgetTypeMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case widgettype.FieldName:
		return m.OldName(ctx)
	}
	return nil, fmt.Errorf("unknown WidgetType field %s", name)
}

// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *WidgetTypeMutation) SetField(name string, value ent.Value) error {
	switch name {
	case widgettype.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	}
	return fmt.Errorf("unknown WidgetType field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WidgetTypeMutation) AddedFields() []string {
	return nil
}

// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *WidgetTypeMutation) AddedField(name string) (ent.Value, bool) {
	return nil, false
}

// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *WidgetTypeMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown WidgetType numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WidgetTypeMutation) ClearedFields() []string {
	return nil
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WidgetTypeMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *WidgetTypeMutation) ClearField(name string) error {
	return fmt.Errorf("unknown WidgetType nullable field %s", name)
}

// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *WidgetTypeMutation) ResetField(name string) error {
	switch name {
	case widgettype.FieldName:
		m.ResetName()
		return nil
	}
	return fmt.Errorf("unknown WidgetType field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *WidgetTypeMutation) AddedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WidgetTypeMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *WidgetTypeMutation) RemovedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *WidgetTypeMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *WidgetTypeMutation) ClearedEdges() []string {
	edges := make([]string, 0, 0)
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WidgetTypeMutation) EdgeCleared(name string) bool {
	return false
}

// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *WidgetTypeMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown WidgetType unique edge %s", name)
}

// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *WidgetTypeMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown WidgetType edge %s", name)
}