mutation.go

// Code generated by ent, DO NOT EDIT.

package oastypes

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"sync"
	"time"

	"entgo.io/contrib/entoas/internal/oastypes/oastypes"
	"entgo.io/contrib/entoas/internal/oastypes/predicate"
	"entgo.io/contrib/entoas/internal/oastypes/schema"
	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	"github.com/google/uuid"
)

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

	// Node types.
	TypeOASTypes = "OASTypes"
)

// OASTypesMutation represents an operation that mutates the OASTypes nodes in the graph.
type OASTypesMutation struct {
	config
	op                       Op
	typ                      string
	id                       *int
	int                      *int
	addint                   *int
	int8                     *int8
	addint8                  *int8
	int16                    *int16
	addint16                 *int16
	int32                    *int32
	addint32                 *int32
	int64                    *int64
	addint64                 *int64
	uint                     *uint
	adduint                  *int
	uint8                    *uint8
	adduint8                 *int8
	uint16                   *uint16
	adduint16                *int16
	uint32                   *uint32
	adduint32                *int32
	uint64                   *uint64
	adduint64                *int64
	float32                  *float32
	addfloat32               *float32
	float64                  *float64
	addfloat64               *float64
	string_field             *string
	bool                     *bool
	uuid                     *uuid.UUID
	time                     *time.Time
	text                     *string
	state                    *oastypes.State
	strings                  *[]string
	appendstrings            []string
	ints                     *[]int
	appendints               []int
	floats                   *[]float64
	appendfloats             []float64
	bytes                    *[]byte
	nicknames                *[]string
	appendnicknames          []string
	json_slice               *[]http.Dir
	appendjson_slice         []http.Dir
	json_obj                 *url.URL
	other                    **schema.Link
	optional                 *int
	addoptional              *int
	nillable                 *int
	addnillable              *int
	optional_and_nillable    *int
	addoptional_and_nillable *int
	clearedFields            map[string]struct{}
	done                     bool
	oldValue                 func(context.Context) (*OASTypes, error)
	predicates               []predicate.OASTypes
}

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

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

// newOASTypesMutation creates new mutation for the OASTypes entity.
func newOASTypesMutation(c config, op Op, opts ...oastypesOption) *OASTypesMutation {
	m := &OASTypesMutation{
		config:        c,
		op:            op,
		typ:           TypeOASTypes,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

// withOASTypesID sets the ID field of the mutation.
func withOASTypesID(id int) oastypesOption {
	return func(m *OASTypesMutation) {
		var (
			err   error
			once  sync.Once
			value *OASTypes
		)
		m.oldValue = func(ctx context.Context) (*OASTypes, error) {
			once.Do(func() {
				if m.done {
					err = errors.New("querying old values post mutation is not allowed")
				} else {
					value, err = m.Client().OASTypes.Get(ctx, id)
				}
			})
			return value, err
		}
		m.id = &id
	}
}

// withOASTypes sets the old OASTypes of the mutation.
func withOASTypes(node *OASTypes) oastypesOption {
	return func(m *OASTypesMutation) {
		m.oldValue = func(context.Context) (*OASTypes, 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 OASTypesMutation) 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 OASTypesMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("oastypes: 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 *OASTypesMutation) ID() (id int, exists bool) {
	if m.id == nil {
		return
	}
	return *m.id, true
}

// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *OASTypesMutation) IDs(ctx context.Context) ([]int, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []int{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().OASTypes.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetInt sets the "int" field.
func (m *OASTypesMutation) SetInt(i int) {
	m.int = &i
	m.addint = nil
}

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

// OldInt returns the old "int" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInt(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInt requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInt: %w", err)
	}
	return oldValue.Int, nil
}

// AddInt adds i to the "int" field.
func (m *OASTypesMutation) AddInt(i int) {
	if m.addint != nil {
		*m.addint += i
	} else {
		m.addint = &i
	}
}

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

// ResetInt resets all changes to the "int" field.
func (m *OASTypesMutation) ResetInt() {
	m.int = nil
	m.addint = nil
}

// SetInt8 sets the "int8" field.
func (m *OASTypesMutation) SetInt8(i int8) {
	m.int8 = &i
	m.addint8 = nil
}

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

// OldInt8 returns the old "int8" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInt8(ctx context.Context) (v int8, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInt8 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInt8 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInt8: %w", err)
	}
	return oldValue.Int8, nil
}

// AddInt8 adds i to the "int8" field.
func (m *OASTypesMutation) AddInt8(i int8) {
	if m.addint8 != nil {
		*m.addint8 += i
	} else {
		m.addint8 = &i
	}
}

// AddedInt8 returns the value that was added to the "int8" field in this mutation.
func (m *OASTypesMutation) AddedInt8() (r int8, exists bool) {
	v := m.addint8
	if v == nil {
		return
	}
	return *v, true
}

// ResetInt8 resets all changes to the "int8" field.
func (m *OASTypesMutation) ResetInt8() {
	m.int8 = nil
	m.addint8 = nil
}

// SetInt16 sets the "int16" field.
func (m *OASTypesMutation) SetInt16(i int16) {
	m.int16 = &i
	m.addint16 = nil
}

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

// OldInt16 returns the old "int16" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInt16(ctx context.Context) (v int16, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInt16 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInt16 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInt16: %w", err)
	}
	return oldValue.Int16, nil
}

// AddInt16 adds i to the "int16" field.
func (m *OASTypesMutation) AddInt16(i int16) {
	if m.addint16 != nil {
		*m.addint16 += i
	} else {
		m.addint16 = &i
	}
}

// AddedInt16 returns the value that was added to the "int16" field in this mutation.
func (m *OASTypesMutation) AddedInt16() (r int16, exists bool) {
	v := m.addint16
	if v == nil {
		return
	}
	return *v, true
}

// ResetInt16 resets all changes to the "int16" field.
func (m *OASTypesMutation) ResetInt16() {
	m.int16 = nil
	m.addint16 = nil
}

// SetInt32 sets the "int32" field.
func (m *OASTypesMutation) SetInt32(i int32) {
	m.int32 = &i
	m.addint32 = nil
}

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

// OldInt32 returns the old "int32" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInt32(ctx context.Context) (v int32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInt32 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInt32 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInt32: %w", err)
	}
	return oldValue.Int32, nil
}

// AddInt32 adds i to the "int32" field.
func (m *OASTypesMutation) AddInt32(i int32) {
	if m.addint32 != nil {
		*m.addint32 += i
	} else {
		m.addint32 = &i
	}
}

// AddedInt32 returns the value that was added to the "int32" field in this mutation.
func (m *OASTypesMutation) AddedInt32() (r int32, exists bool) {
	v := m.addint32
	if v == nil {
		return
	}
	return *v, true
}

// ResetInt32 resets all changes to the "int32" field.
func (m *OASTypesMutation) ResetInt32() {
	m.int32 = nil
	m.addint32 = nil
}

// SetInt64 sets the "int64" field.
func (m *OASTypesMutation) SetInt64(i int64) {
	m.int64 = &i
	m.addint64 = nil
}

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

// OldInt64 returns the old "int64" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInt64(ctx context.Context) (v int64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInt64 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInt64 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInt64: %w", err)
	}
	return oldValue.Int64, nil
}

// AddInt64 adds i to the "int64" field.
func (m *OASTypesMutation) AddInt64(i int64) {
	if m.addint64 != nil {
		*m.addint64 += i
	} else {
		m.addint64 = &i
	}
}

// AddedInt64 returns the value that was added to the "int64" field in this mutation.
func (m *OASTypesMutation) AddedInt64() (r int64, exists bool) {
	v := m.addint64
	if v == nil {
		return
	}
	return *v, true
}

// ResetInt64 resets all changes to the "int64" field.
func (m *OASTypesMutation) ResetInt64() {
	m.int64 = nil
	m.addint64 = nil
}

// SetUint sets the "uint" field.
func (m *OASTypesMutation) SetUint(u uint) {
	m.uint = &u
	m.adduint = nil
}

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

// OldUint returns the old "uint" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUint(ctx context.Context) (v uint, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUint is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUint requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUint: %w", err)
	}
	return oldValue.Uint, nil
}

// AddUint adds u to the "uint" field.
func (m *OASTypesMutation) AddUint(u int) {
	if m.adduint != nil {
		*m.adduint += u
	} else {
		m.adduint = &u
	}
}

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

// ResetUint resets all changes to the "uint" field.
func (m *OASTypesMutation) ResetUint() {
	m.uint = nil
	m.adduint = nil
}

// SetUint8 sets the "uint8" field.
func (m *OASTypesMutation) SetUint8(u uint8) {
	m.uint8 = &u
	m.adduint8 = nil
}

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

// OldUint8 returns the old "uint8" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUint8(ctx context.Context) (v uint8, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUint8 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUint8 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUint8: %w", err)
	}
	return oldValue.Uint8, nil
}

// AddUint8 adds u to the "uint8" field.
func (m *OASTypesMutation) AddUint8(u int8) {
	if m.adduint8 != nil {
		*m.adduint8 += u
	} else {
		m.adduint8 = &u
	}
}

// AddedUint8 returns the value that was added to the "uint8" field in this mutation.
func (m *OASTypesMutation) AddedUint8() (r int8, exists bool) {
	v := m.adduint8
	if v == nil {
		return
	}
	return *v, true
}

// ResetUint8 resets all changes to the "uint8" field.
func (m *OASTypesMutation) ResetUint8() {
	m.uint8 = nil
	m.adduint8 = nil
}

// SetUint16 sets the "uint16" field.
func (m *OASTypesMutation) SetUint16(u uint16) {
	m.uint16 = &u
	m.adduint16 = nil
}

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

// OldUint16 returns the old "uint16" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUint16(ctx context.Context) (v uint16, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUint16 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUint16 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUint16: %w", err)
	}
	return oldValue.Uint16, nil
}

// AddUint16 adds u to the "uint16" field.
func (m *OASTypesMutation) AddUint16(u int16) {
	if m.adduint16 != nil {
		*m.adduint16 += u
	} else {
		m.adduint16 = &u
	}
}

// AddedUint16 returns the value that was added to the "uint16" field in this mutation.
func (m *OASTypesMutation) AddedUint16() (r int16, exists bool) {
	v := m.adduint16
	if v == nil {
		return
	}
	return *v, true
}

// ResetUint16 resets all changes to the "uint16" field.
func (m *OASTypesMutation) ResetUint16() {
	m.uint16 = nil
	m.adduint16 = nil
}

// SetUint32 sets the "uint32" field.
func (m *OASTypesMutation) SetUint32(u uint32) {
	m.uint32 = &u
	m.adduint32 = nil
}

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

// OldUint32 returns the old "uint32" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUint32(ctx context.Context) (v uint32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUint32 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUint32 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUint32: %w", err)
	}
	return oldValue.Uint32, nil
}

// AddUint32 adds u to the "uint32" field.
func (m *OASTypesMutation) AddUint32(u int32) {
	if m.adduint32 != nil {
		*m.adduint32 += u
	} else {
		m.adduint32 = &u
	}
}

// AddedUint32 returns the value that was added to the "uint32" field in this mutation.
func (m *OASTypesMutation) AddedUint32() (r int32, exists bool) {
	v := m.adduint32
	if v == nil {
		return
	}
	return *v, true
}

// ResetUint32 resets all changes to the "uint32" field.
func (m *OASTypesMutation) ResetUint32() {
	m.uint32 = nil
	m.adduint32 = nil
}

// SetUint64 sets the "uint64" field.
func (m *OASTypesMutation) SetUint64(u uint64) {
	m.uint64 = &u
	m.adduint64 = nil
}

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

// OldUint64 returns the old "uint64" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUint64(ctx context.Context) (v uint64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUint64 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUint64 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUint64: %w", err)
	}
	return oldValue.Uint64, nil
}

// AddUint64 adds u to the "uint64" field.
func (m *OASTypesMutation) AddUint64(u int64) {
	if m.adduint64 != nil {
		*m.adduint64 += u
	} else {
		m.adduint64 = &u
	}
}

// AddedUint64 returns the value that was added to the "uint64" field in this mutation.
func (m *OASTypesMutation) AddedUint64() (r int64, exists bool) {
	v := m.adduint64
	if v == nil {
		return
	}
	return *v, true
}

// ResetUint64 resets all changes to the "uint64" field.
func (m *OASTypesMutation) ResetUint64() {
	m.uint64 = nil
	m.adduint64 = nil
}

// SetFloat32 sets the "float32" field.
func (m *OASTypesMutation) SetFloat32(f float32) {
	m.float32 = &f
	m.addfloat32 = nil
}

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

// OldFloat32 returns the old "float32" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldFloat32(ctx context.Context) (v float32, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldFloat32 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldFloat32 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldFloat32: %w", err)
	}
	return oldValue.Float32, nil
}

// AddFloat32 adds f to the "float32" field.
func (m *OASTypesMutation) AddFloat32(f float32) {
	if m.addfloat32 != nil {
		*m.addfloat32 += f
	} else {
		m.addfloat32 = &f
	}
}

// AddedFloat32 returns the value that was added to the "float32" field in this mutation.
func (m *OASTypesMutation) AddedFloat32() (r float32, exists bool) {
	v := m.addfloat32
	if v == nil {
		return
	}
	return *v, true
}

// ResetFloat32 resets all changes to the "float32" field.
func (m *OASTypesMutation) ResetFloat32() {
	m.float32 = nil
	m.addfloat32 = nil
}

// SetFloat64 sets the "float64" field.
func (m *OASTypesMutation) SetFloat64(f float64) {
	m.float64 = &f
	m.addfloat64 = nil
}

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

// OldFloat64 returns the old "float64" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldFloat64(ctx context.Context) (v float64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldFloat64 is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldFloat64 requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldFloat64: %w", err)
	}
	return oldValue.Float64, nil
}

// AddFloat64 adds f to the "float64" field.
func (m *OASTypesMutation) AddFloat64(f float64) {
	if m.addfloat64 != nil {
		*m.addfloat64 += f
	} else {
		m.addfloat64 = &f
	}
}

// AddedFloat64 returns the value that was added to the "float64" field in this mutation.
func (m *OASTypesMutation) AddedFloat64() (r float64, exists bool) {
	v := m.addfloat64
	if v == nil {
		return
	}
	return *v, true
}

// ResetFloat64 resets all changes to the "float64" field.
func (m *OASTypesMutation) ResetFloat64() {
	m.float64 = nil
	m.addfloat64 = nil
}

// SetStringField sets the "string_field" field.
func (m *OASTypesMutation) SetStringField(s string) {
	m.string_field = &s
}

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

// OldStringField returns the old "string_field" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldStringField(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStringField is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStringField requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStringField: %w", err)
	}
	return oldValue.StringField, nil
}

// ResetStringField resets all changes to the "string_field" field.
func (m *OASTypesMutation) ResetStringField() {
	m.string_field = nil
}

// SetBool sets the "bool" field.
func (m *OASTypesMutation) SetBool(b bool) {
	m.bool = &b
}

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

// OldBool returns the old "bool" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldBool(ctx context.Context) (v bool, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBool is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBool requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBool: %w", err)
	}
	return oldValue.Bool, nil
}

// ResetBool resets all changes to the "bool" field.
func (m *OASTypesMutation) ResetBool() {
	m.bool = nil
}

// SetUUID sets the "uuid" field.
func (m *OASTypesMutation) SetUUID(u uuid.UUID) {
	m.uuid = &u
}

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

// OldUUID returns the old "uuid" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldUUID(ctx context.Context) (v uuid.UUID, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldUUID is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldUUID requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldUUID: %w", err)
	}
	return oldValue.UUID, nil
}

// ResetUUID resets all changes to the "uuid" field.
func (m *OASTypesMutation) ResetUUID() {
	m.uuid = nil
}

// SetTime sets the "time" field.
func (m *OASTypesMutation) SetTime(t time.Time) {
	m.time = &t
}

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

// OldTime returns the old "time" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldTime(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldTime is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldTime requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldTime: %w", err)
	}
	return oldValue.Time, nil
}

// ResetTime resets all changes to the "time" field.
func (m *OASTypesMutation) ResetTime() {
	m.time = nil
}

// SetText sets the "text" field.
func (m *OASTypesMutation) SetText(s string) {
	m.text = &s
}

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

// OldText returns the old "text" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldText(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldText is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldText requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldText: %w", err)
	}
	return oldValue.Text, nil
}

// ResetText resets all changes to the "text" field.
func (m *OASTypesMutation) ResetText() {
	m.text = nil
}

// SetState sets the "state" field.
func (m *OASTypesMutation) SetState(o oastypes.State) {
	m.state = &o
}

// State returns the value of the "state" field in the mutation.
func (m *OASTypesMutation) State() (r oastypes.State, exists bool) {
	v := m.state
	if v == nil {
		return
	}
	return *v, true
}

// OldState returns the old "state" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldState(ctx context.Context) (v oastypes.State, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldState is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldState requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldState: %w", err)
	}
	return oldValue.State, nil
}

// ResetState resets all changes to the "state" field.
func (m *OASTypesMutation) ResetState() {
	m.state = nil
}

// SetStrings sets the "strings" field.
func (m *OASTypesMutation) SetStrings(s []string) {
	m.strings = &s
	m.appendstrings = nil
}

// Strings returns the value of the "strings" field in the mutation.
func (m *OASTypesMutation) Strings() (r []string, exists bool) {
	v := m.strings
	if v == nil {
		return
	}
	return *v, true
}

// OldStrings returns the old "strings" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldStrings(ctx context.Context) (v []string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldStrings is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldStrings requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldStrings: %w", err)
	}
	return oldValue.Strings, nil
}

// AppendStrings adds s to the "strings" field.
func (m *OASTypesMutation) AppendStrings(s []string) {
	m.appendstrings = append(m.appendstrings, s...)
}

// AppendedStrings returns the list of values that were appended to the "strings" field in this mutation.
func (m *OASTypesMutation) AppendedStrings() ([]string, bool) {
	if len(m.appendstrings) == 0 {
		return nil, false
	}
	return m.appendstrings, true
}

// ResetStrings resets all changes to the "strings" field.
func (m *OASTypesMutation) ResetStrings() {
	m.strings = nil
	m.appendstrings = nil
}

// SetInts sets the "ints" field.
func (m *OASTypesMutation) SetInts(i []int) {
	m.ints = &i
	m.appendints = nil
}

// Ints returns the value of the "ints" field in the mutation.
func (m *OASTypesMutation) Ints() (r []int, exists bool) {
	v := m.ints
	if v == nil {
		return
	}
	return *v, true
}

// OldInts returns the old "ints" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldInts(ctx context.Context) (v []int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldInts is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldInts requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldInts: %w", err)
	}
	return oldValue.Ints, nil
}

// AppendInts adds i to the "ints" field.
func (m *OASTypesMutation) AppendInts(i []int) {
	m.appendints = append(m.appendints, i...)
}

// AppendedInts returns the list of values that were appended to the "ints" field in this mutation.
func (m *OASTypesMutation) AppendedInts() ([]int, bool) {
	if len(m.appendints) == 0 {
		return nil, false
	}
	return m.appendints, true
}

// ResetInts resets all changes to the "ints" field.
func (m *OASTypesMutation) ResetInts() {
	m.ints = nil
	m.appendints = nil
}

// SetFloats sets the "floats" field.
func (m *OASTypesMutation) SetFloats(f []float64) {
	m.floats = &f
	m.appendfloats = nil
}

// Floats returns the value of the "floats" field in the mutation.
func (m *OASTypesMutation) Floats() (r []float64, exists bool) {
	v := m.floats
	if v == nil {
		return
	}
	return *v, true
}

// OldFloats returns the old "floats" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldFloats(ctx context.Context) (v []float64, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldFloats is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldFloats requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldFloats: %w", err)
	}
	return oldValue.Floats, nil
}

// AppendFloats adds f to the "floats" field.
func (m *OASTypesMutation) AppendFloats(f []float64) {
	m.appendfloats = append(m.appendfloats, f...)
}

// AppendedFloats returns the list of values that were appended to the "floats" field in this mutation.
func (m *OASTypesMutation) AppendedFloats() ([]float64, bool) {
	if len(m.appendfloats) == 0 {
		return nil, false
	}
	return m.appendfloats, true
}

// ResetFloats resets all changes to the "floats" field.
func (m *OASTypesMutation) ResetFloats() {
	m.floats = nil
	m.appendfloats = nil
}

// SetBytes sets the "bytes" field.
func (m *OASTypesMutation) SetBytes(b []byte) {
	m.bytes = &b
}

// Bytes returns the value of the "bytes" field in the mutation.
func (m *OASTypesMutation) Bytes() (r []byte, exists bool) {
	v := m.bytes
	if v == nil {
		return
	}
	return *v, true
}

// OldBytes returns the old "bytes" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldBytes(ctx context.Context) (v []byte, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldBytes is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldBytes requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldBytes: %w", err)
	}
	return oldValue.Bytes, nil
}

// ResetBytes resets all changes to the "bytes" field.
func (m *OASTypesMutation) ResetBytes() {
	m.bytes = nil
}

// SetNicknames sets the "nicknames" field.
func (m *OASTypesMutation) SetNicknames(s []string) {
	m.nicknames = &s
	m.appendnicknames = nil
}

// Nicknames returns the value of the "nicknames" field in the mutation.
func (m *OASTypesMutation) Nicknames() (r []string, exists bool) {
	v := m.nicknames
	if v == nil {
		return
	}
	return *v, true
}

// OldNicknames returns the old "nicknames" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldNicknames(ctx context.Context) (v []string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNicknames is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNicknames requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNicknames: %w", err)
	}
	return oldValue.Nicknames, nil
}

// AppendNicknames adds s to the "nicknames" field.
func (m *OASTypesMutation) AppendNicknames(s []string) {
	m.appendnicknames = append(m.appendnicknames, s...)
}

// AppendedNicknames returns the list of values that were appended to the "nicknames" field in this mutation.
func (m *OASTypesMutation) AppendedNicknames() ([]string, bool) {
	if len(m.appendnicknames) == 0 {
		return nil, false
	}
	return m.appendnicknames, true
}

// ResetNicknames resets all changes to the "nicknames" field.
func (m *OASTypesMutation) ResetNicknames() {
	m.nicknames = nil
	m.appendnicknames = nil
}

// SetJSONSlice sets the "json_slice" field.
func (m *OASTypesMutation) SetJSONSlice(h []http.Dir) {
	m.json_slice = &h
	m.appendjson_slice = nil
}

// JSONSlice returns the value of the "json_slice" field in the mutation.
func (m *OASTypesMutation) JSONSlice() (r []http.Dir, exists bool) {
	v := m.json_slice
	if v == nil {
		return
	}
	return *v, true
}

// OldJSONSlice returns the old "json_slice" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldJSONSlice(ctx context.Context) (v []http.Dir, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldJSONSlice is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldJSONSlice requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldJSONSlice: %w", err)
	}
	return oldValue.JSONSlice, nil
}

// AppendJSONSlice adds h to the "json_slice" field.
func (m *OASTypesMutation) AppendJSONSlice(h []http.Dir) {
	m.appendjson_slice = append(m.appendjson_slice, h...)
}

// AppendedJSONSlice returns the list of values that were appended to the "json_slice" field in this mutation.
func (m *OASTypesMutation) AppendedJSONSlice() ([]http.Dir, bool) {
	if len(m.appendjson_slice) == 0 {
		return nil, false
	}
	return m.appendjson_slice, true
}

// ResetJSONSlice resets all changes to the "json_slice" field.
func (m *OASTypesMutation) ResetJSONSlice() {
	m.json_slice = nil
	m.appendjson_slice = nil
}

// SetJSONObj sets the "json_obj" field.
func (m *OASTypesMutation) SetJSONObj(u url.URL) {
	m.json_obj = &u
}

// JSONObj returns the value of the "json_obj" field in the mutation.
func (m *OASTypesMutation) JSONObj() (r url.URL, exists bool) {
	v := m.json_obj
	if v == nil {
		return
	}
	return *v, true
}

// OldJSONObj returns the old "json_obj" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldJSONObj(ctx context.Context) (v url.URL, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldJSONObj is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldJSONObj requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldJSONObj: %w", err)
	}
	return oldValue.JSONObj, nil
}

// ResetJSONObj resets all changes to the "json_obj" field.
func (m *OASTypesMutation) ResetJSONObj() {
	m.json_obj = nil
}

// SetOther sets the "other" field.
func (m *OASTypesMutation) SetOther(s *schema.Link) {
	m.other = &s
}

// Other returns the value of the "other" field in the mutation.
func (m *OASTypesMutation) Other() (r *schema.Link, exists bool) {
	v := m.other
	if v == nil {
		return
	}
	return *v, true
}

// OldOther returns the old "other" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldOther(ctx context.Context) (v *schema.Link, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOther is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOther requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOther: %w", err)
	}
	return oldValue.Other, nil
}

// ResetOther resets all changes to the "other" field.
func (m *OASTypesMutation) ResetOther() {
	m.other = nil
}

// SetOptional sets the "optional" field.
func (m *OASTypesMutation) SetOptional(i int) {
	m.optional = &i
	m.addoptional = nil
}

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

// OldOptional returns the old "optional" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldOptional(ctx context.Context) (v int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOptional is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOptional requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOptional: %w", err)
	}
	return oldValue.Optional, nil
}

// AddOptional adds i to the "optional" field.
func (m *OASTypesMutation) AddOptional(i int) {
	if m.addoptional != nil {
		*m.addoptional += i
	} else {
		m.addoptional = &i
	}
}

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

// ClearOptional clears the value of the "optional" field.
func (m *OASTypesMutation) ClearOptional() {
	m.optional = nil
	m.addoptional = nil
	m.clearedFields[oastypes.FieldOptional] = struct{}{}
}

// OptionalCleared returns if the "optional" field was cleared in this mutation.
func (m *OASTypesMutation) OptionalCleared() bool {
	_, ok := m.clearedFields[oastypes.FieldOptional]
	return ok
}

// ResetOptional resets all changes to the "optional" field.
func (m *OASTypesMutation) ResetOptional() {
	m.optional = nil
	m.addoptional = nil
	delete(m.clearedFields, oastypes.FieldOptional)
}

// SetNillable sets the "nillable" field.
func (m *OASTypesMutation) SetNillable(i int) {
	m.nillable = &i
	m.addnillable = nil
}

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

// OldNillable returns the old "nillable" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldNillable(ctx context.Context) (v *int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldNillable is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldNillable requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldNillable: %w", err)
	}
	return oldValue.Nillable, nil
}

// AddNillable adds i to the "nillable" field.
func (m *OASTypesMutation) AddNillable(i int) {
	if m.addnillable != nil {
		*m.addnillable += i
	} else {
		m.addnillable = &i
	}
}

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

// ResetNillable resets all changes to the "nillable" field.
func (m *OASTypesMutation) ResetNillable() {
	m.nillable = nil
	m.addnillable = nil
}

// SetOptionalAndNillable sets the "optional_and_nillable" field.
func (m *OASTypesMutation) SetOptionalAndNillable(i int) {
	m.optional_and_nillable = &i
	m.addoptional_and_nillable = nil
}

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

// OldOptionalAndNillable returns the old "optional_and_nillable" field's value of the OASTypes entity.
// If the OASTypes 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 *OASTypesMutation) OldOptionalAndNillable(ctx context.Context) (v *int, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldOptionalAndNillable is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("OldOptionalAndNillable requires an ID field in the mutation")
	}
	oldValue, err := m.oldValue(ctx)
	if err != nil {
		return v, fmt.Errorf("querying old value for OldOptionalAndNillable: %w", err)
	}
	return oldValue.OptionalAndNillable, nil
}

// AddOptionalAndNillable adds i to the "optional_and_nillable" field.
func (m *OASTypesMutation) AddOptionalAndNillable(i int) {
	if m.addoptional_and_nillable != nil {
		*m.addoptional_and_nillable += i
	} else {
		m.addoptional_and_nillable = &i
	}
}

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

// ClearOptionalAndNillable clears the value of the "optional_and_nillable" field.
func (m *OASTypesMutation) ClearOptionalAndNillable() {
	m.optional_and_nillable = nil
	m.addoptional_and_nillable = nil
	m.clearedFields[oastypes.FieldOptionalAndNillable] = struct{}{}
}

// OptionalAndNillableCleared returns if the "optional_and_nillable" field was cleared in this mutation.
func (m *OASTypesMutation) OptionalAndNillableCleared() bool {
	_, ok := m.clearedFields[oastypes.FieldOptionalAndNillable]
	return ok
}

// ResetOptionalAndNillable resets all changes to the "optional_and_nillable" field.
func (m *OASTypesMutation) ResetOptionalAndNillable() {
	m.optional_and_nillable = nil
	m.addoptional_and_nillable = nil
	delete(m.clearedFields, oastypes.FieldOptionalAndNillable)
}

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

// WhereP appends storage-level predicates to the OASTypesMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *OASTypesMutation) WhereP(ps ...func(*sql.Selector)) {
	p := make([]predicate.OASTypes, len(ps))
	for i := range ps {
		p[i] = ps[i]
	}
	m.Where(p...)
}

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

// SetOp allows setting the mutation operation.
func (m *OASTypesMutation) SetOp(op Op) {
	m.op = op
}

// Type returns the node type of this mutation (OASTypes).
func (m *OASTypesMutation) 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 *OASTypesMutation) Fields() []string {
	fields := make([]string, 0, 29)
	if m.int != nil {
		fields = append(fields, oastypes.FieldInt)
	}
	if m.int8 != nil {
		fields = append(fields, oastypes.FieldInt8)
	}
	if m.int16 != nil {
		fields = append(fields, oastypes.FieldInt16)
	}
	if m.int32 != nil {
		fields = append(fields, oastypes.FieldInt32)
	}
	if m.int64 != nil {
		fields = append(fields, oastypes.FieldInt64)
	}
	if m.uint != nil {
		fields = append(fields, oastypes.FieldUint)
	}
	if m.uint8 != nil {
		fields = append(fields, oastypes.FieldUint8)
	}
	if m.uint16 != nil {
		fields = append(fields, oastypes.FieldUint16)
	}
	if m.uint32 != nil {
		fields = append(fields, oastypes.FieldUint32)
	}
	if m.uint64 != nil {
		fields = append(fields, oastypes.FieldUint64)
	}
	if m.float32 != nil {
		fields = append(fields, oastypes.FieldFloat32)
	}
	if m.float64 != nil {
		fields = append(fields, oastypes.FieldFloat64)
	}
	if m.string_field != nil {
		fields = append(fields, oastypes.FieldStringField)
	}
	if m.bool != nil {
		fields = append(fields, oastypes.FieldBool)
	}
	if m.uuid != nil {
		fields = append(fields, oastypes.FieldUUID)
	}
	if m.time != nil {
		fields = append(fields, oastypes.FieldTime)
	}
	if m.text != nil {
		fields = append(fields, oastypes.FieldText)
	}
	if m.state != nil {
		fields = append(fields, oastypes.FieldState)
	}
	if m.strings != nil {
		fields = append(fields, oastypes.FieldStrings)
	}
	if m.ints != nil {
		fields = append(fields, oastypes.FieldInts)
	}
	if m.floats != nil {
		fields = append(fields, oastypes.FieldFloats)
	}
	if m.bytes != nil {
		fields = append(fields, oastypes.FieldBytes)
	}
	if m.nicknames != nil {
		fields = append(fields, oastypes.FieldNicknames)
	}
	if m.json_slice != nil {
		fields = append(fields, oastypes.FieldJSONSlice)
	}
	if m.json_obj != nil {
		fields = append(fields, oastypes.FieldJSONObj)
	}
	if m.other != nil {
		fields = append(fields, oastypes.FieldOther)
	}
	if m.optional != nil {
		fields = append(fields, oastypes.FieldOptional)
	}
	if m.nillable != nil {
		fields = append(fields, oastypes.FieldNillable)
	}
	if m.optional_and_nillable != nil {
		fields = append(fields, oastypes.FieldOptionalAndNillable)
	}
	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 *OASTypesMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case oastypes.FieldInt:
		return m.Int()
	case oastypes.FieldInt8:
		return m.Int8()
	case oastypes.FieldInt16:
		return m.Int16()
	case oastypes.FieldInt32:
		return m.Int32()
	case oastypes.FieldInt64:
		return m.Int64()
	case oastypes.FieldUint:
		return m.Uint()
	case oastypes.FieldUint8:
		return m.Uint8()
	case oastypes.FieldUint16:
		return m.Uint16()
	case oastypes.FieldUint32:
		return m.Uint32()
	case oastypes.FieldUint64:
		return m.Uint64()
	case oastypes.FieldFloat32:
		return m.Float32()
	case oastypes.FieldFloat64:
		return m.Float64()
	case oastypes.FieldStringField:
		return m.StringField()
	case oastypes.FieldBool:
		return m.Bool()
	case oastypes.FieldUUID:
		return m.UUID()
	case oastypes.FieldTime:
		return m.Time()
	case oastypes.FieldText:
		return m.Text()
	case oastypes.FieldState:
		return m.State()
	case oastypes.FieldStrings:
		return m.Strings()
	case oastypes.FieldInts:
		return m.Ints()
	case oastypes.FieldFloats:
		return m.Floats()
	case oastypes.FieldBytes:
		return m.Bytes()
	case oastypes.FieldNicknames:
		return m.Nicknames()
	case oastypes.FieldJSONSlice:
		return m.JSONSlice()
	case oastypes.FieldJSONObj:
		return m.JSONObj()
	case oastypes.FieldOther:
		return m.Other()
	case oastypes.FieldOptional:
		return m.Optional()
	case oastypes.FieldNillable:
		return m.Nillable()
	case oastypes.FieldOptionalAndNillable:
		return m.OptionalAndNillable()
	}
	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 *OASTypesMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case oastypes.FieldInt:
		return m.OldInt(ctx)
	case oastypes.FieldInt8:
		return m.OldInt8(ctx)
	case oastypes.FieldInt16:
		return m.OldInt16(ctx)
	case oastypes.FieldInt32:
		return m.OldInt32(ctx)
	case oastypes.FieldInt64:
		return m.OldInt64(ctx)
	case oastypes.FieldUint:
		return m.OldUint(ctx)
	case oastypes.FieldUint8:
		return m.OldUint8(ctx)
	case oastypes.FieldUint16:
		return m.OldUint16(ctx)
	case oastypes.FieldUint32:
		return m.OldUint32(ctx)
	case oastypes.FieldUint64:
		return m.OldUint64(ctx)
	case oastypes.FieldFloat32:
		return m.OldFloat32(ctx)
	case oastypes.FieldFloat64:
		return m.OldFloat64(ctx)
	case oastypes.FieldStringField:
		return m.OldStringField(ctx)
	case oastypes.FieldBool:
		return m.OldBool(ctx)
	case oastypes.FieldUUID:
		return m.OldUUID(ctx)
	case oastypes.FieldTime:
		return m.OldTime(ctx)
	case oastypes.FieldText:
		return m.OldText(ctx)
	case oastypes.FieldState:
		return m.OldState(ctx)
	case oastypes.FieldStrings:
		return m.OldStrings(ctx)
	case oastypes.FieldInts:
		return m.OldInts(ctx)
	case oastypes.FieldFloats:
		return m.OldFloats(ctx)
	case oastypes.FieldBytes:
		return m.OldBytes(ctx)
	case oastypes.FieldNicknames:
		return m.OldNicknames(ctx)
	case oastypes.FieldJSONSlice:
		return m.OldJSONSlice(ctx)
	case oastypes.FieldJSONObj:
		return m.OldJSONObj(ctx)
	case oastypes.FieldOther:
		return m.OldOther(ctx)
	case oastypes.FieldOptional:
		return m.OldOptional(ctx)
	case oastypes.FieldNillable:
		return m.OldNillable(ctx)
	case oastypes.FieldOptionalAndNillable:
		return m.OldOptionalAndNillable(ctx)
	}
	return nil, fmt.Errorf("unknown OASTypes 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 *OASTypesMutation) SetField(name string, value ent.Value) error {
	switch name {
	case oastypes.FieldInt:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInt(v)
		return nil
	case oastypes.FieldInt8:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInt8(v)
		return nil
	case oastypes.FieldInt16:
		v, ok := value.(int16)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInt16(v)
		return nil
	case oastypes.FieldInt32:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInt32(v)
		return nil
	case oastypes.FieldInt64:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInt64(v)
		return nil
	case oastypes.FieldUint:
		v, ok := value.(uint)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUint(v)
		return nil
	case oastypes.FieldUint8:
		v, ok := value.(uint8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUint8(v)
		return nil
	case oastypes.FieldUint16:
		v, ok := value.(uint16)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUint16(v)
		return nil
	case oastypes.FieldUint32:
		v, ok := value.(uint32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUint32(v)
		return nil
	case oastypes.FieldUint64:
		v, ok := value.(uint64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUint64(v)
		return nil
	case oastypes.FieldFloat32:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFloat32(v)
		return nil
	case oastypes.FieldFloat64:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFloat64(v)
		return nil
	case oastypes.FieldStringField:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStringField(v)
		return nil
	case oastypes.FieldBool:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBool(v)
		return nil
	case oastypes.FieldUUID:
		v, ok := value.(uuid.UUID)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUUID(v)
		return nil
	case oastypes.FieldTime:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTime(v)
		return nil
	case oastypes.FieldText:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetText(v)
		return nil
	case oastypes.FieldState:
		v, ok := value.(oastypes.State)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetState(v)
		return nil
	case oastypes.FieldStrings:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetStrings(v)
		return nil
	case oastypes.FieldInts:
		v, ok := value.([]int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetInts(v)
		return nil
	case oastypes.FieldFloats:
		v, ok := value.([]float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFloats(v)
		return nil
	case oastypes.FieldBytes:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBytes(v)
		return nil
	case oastypes.FieldNicknames:
		v, ok := value.([]string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNicknames(v)
		return nil
	case oastypes.FieldJSONSlice:
		v, ok := value.([]http.Dir)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetJSONSlice(v)
		return nil
	case oastypes.FieldJSONObj:
		v, ok := value.(url.URL)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetJSONObj(v)
		return nil
	case oastypes.FieldOther:
		v, ok := value.(*schema.Link)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOther(v)
		return nil
	case oastypes.FieldOptional:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOptional(v)
		return nil
	case oastypes.FieldNillable:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetNillable(v)
		return nil
	case oastypes.FieldOptionalAndNillable:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetOptionalAndNillable(v)
		return nil
	}
	return fmt.Errorf("unknown OASTypes field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OASTypesMutation) AddedFields() []string {
	var fields []string
	if m.addint != nil {
		fields = append(fields, oastypes.FieldInt)
	}
	if m.addint8 != nil {
		fields = append(fields, oastypes.FieldInt8)
	}
	if m.addint16 != nil {
		fields = append(fields, oastypes.FieldInt16)
	}
	if m.addint32 != nil {
		fields = append(fields, oastypes.FieldInt32)
	}
	if m.addint64 != nil {
		fields = append(fields, oastypes.FieldInt64)
	}
	if m.adduint != nil {
		fields = append(fields, oastypes.FieldUint)
	}
	if m.adduint8 != nil {
		fields = append(fields, oastypes.FieldUint8)
	}
	if m.adduint16 != nil {
		fields = append(fields, oastypes.FieldUint16)
	}
	if m.adduint32 != nil {
		fields = append(fields, oastypes.FieldUint32)
	}
	if m.adduint64 != nil {
		fields = append(fields, oastypes.FieldUint64)
	}
	if m.addfloat32 != nil {
		fields = append(fields, oastypes.FieldFloat32)
	}
	if m.addfloat64 != nil {
		fields = append(fields, oastypes.FieldFloat64)
	}
	if m.addoptional != nil {
		fields = append(fields, oastypes.FieldOptional)
	}
	if m.addnillable != nil {
		fields = append(fields, oastypes.FieldNillable)
	}
	if m.addoptional_and_nillable != nil {
		fields = append(fields, oastypes.FieldOptionalAndNillable)
	}
	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 *OASTypesMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case oastypes.FieldInt:
		return m.AddedInt()
	case oastypes.FieldInt8:
		return m.AddedInt8()
	case oastypes.FieldInt16:
		return m.AddedInt16()
	case oastypes.FieldInt32:
		return m.AddedInt32()
	case oastypes.FieldInt64:
		return m.AddedInt64()
	case oastypes.FieldUint:
		return m.AddedUint()
	case oastypes.FieldUint8:
		return m.AddedUint8()
	case oastypes.FieldUint16:
		return m.AddedUint16()
	case oastypes.FieldUint32:
		return m.AddedUint32()
	case oastypes.FieldUint64:
		return m.AddedUint64()
	case oastypes.FieldFloat32:
		return m.AddedFloat32()
	case oastypes.FieldFloat64:
		return m.AddedFloat64()
	case oastypes.FieldOptional:
		return m.AddedOptional()
	case oastypes.FieldNillable:
		return m.AddedNillable()
	case oastypes.FieldOptionalAndNillable:
		return m.AddedOptionalAndNillable()
	}
	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 *OASTypesMutation) AddField(name string, value ent.Value) error {
	switch name {
	case oastypes.FieldInt:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddInt(v)
		return nil
	case oastypes.FieldInt8:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddInt8(v)
		return nil
	case oastypes.FieldInt16:
		v, ok := value.(int16)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddInt16(v)
		return nil
	case oastypes.FieldInt32:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddInt32(v)
		return nil
	case oastypes.FieldInt64:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddInt64(v)
		return nil
	case oastypes.FieldUint:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUint(v)
		return nil
	case oastypes.FieldUint8:
		v, ok := value.(int8)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUint8(v)
		return nil
	case oastypes.FieldUint16:
		v, ok := value.(int16)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUint16(v)
		return nil
	case oastypes.FieldUint32:
		v, ok := value.(int32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUint32(v)
		return nil
	case oastypes.FieldUint64:
		v, ok := value.(int64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddUint64(v)
		return nil
	case oastypes.FieldFloat32:
		v, ok := value.(float32)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddFloat32(v)
		return nil
	case oastypes.FieldFloat64:
		v, ok := value.(float64)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddFloat64(v)
		return nil
	case oastypes.FieldOptional:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOptional(v)
		return nil
	case oastypes.FieldNillable:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddNillable(v)
		return nil
	case oastypes.FieldOptionalAndNillable:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddOptionalAndNillable(v)
		return nil
	}
	return fmt.Errorf("unknown OASTypes numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *OASTypesMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(oastypes.FieldOptional) {
		fields = append(fields, oastypes.FieldOptional)
	}
	if m.FieldCleared(oastypes.FieldOptionalAndNillable) {
		fields = append(fields, oastypes.FieldOptionalAndNillable)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OASTypesMutation) 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 *OASTypesMutation) ClearField(name string) error {
	switch name {
	case oastypes.FieldOptional:
		m.ClearOptional()
		return nil
	case oastypes.FieldOptionalAndNillable:
		m.ClearOptionalAndNillable()
		return nil
	}
	return fmt.Errorf("unknown OASTypes 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 *OASTypesMutation) ResetField(name string) error {
	switch name {
	case oastypes.FieldInt:
		m.ResetInt()
		return nil
	case oastypes.FieldInt8:
		m.ResetInt8()
		return nil
	case oastypes.FieldInt16:
		m.ResetInt16()
		return nil
	case oastypes.FieldInt32:
		m.ResetInt32()
		return nil
	case oastypes.FieldInt64:
		m.ResetInt64()
		return nil
	case oastypes.FieldUint:
		m.ResetUint()
		return nil
	case oastypes.FieldUint8:
		m.ResetUint8()
		return nil
	case oastypes.FieldUint16:
		m.ResetUint16()
		return nil
	case oastypes.FieldUint32:
		m.ResetUint32()
		return nil
	case oastypes.FieldUint64:
		m.ResetUint64()
		return nil
	case oastypes.FieldFloat32:
		m.ResetFloat32()
		return nil
	case oastypes.FieldFloat64:
		m.ResetFloat64()
		return nil
	case oastypes.FieldStringField:
		m.ResetStringField()
		return nil
	case oastypes.FieldBool:
		m.ResetBool()
		return nil
	case oastypes.FieldUUID:
		m.ResetUUID()
		return nil
	case oastypes.FieldTime:
		m.ResetTime()
		return nil
	case oastypes.FieldText:
		m.ResetText()
		return nil
	case oastypes.FieldState:
		m.ResetState()
		return nil
	case oastypes.FieldStrings:
		m.ResetStrings()
		return nil
	case oastypes.FieldInts:
		m.ResetInts()
		return nil
	case oastypes.FieldFloats:
		m.ResetFloats()
		return nil
	case oastypes.FieldBytes:
		m.ResetBytes()
		return nil
	case oastypes.FieldNicknames:
		m.ResetNicknames()
		return nil
	case oastypes.FieldJSONSlice:
		m.ResetJSONSlice()
		return nil
	case oastypes.FieldJSONObj:
		m.ResetJSONObj()
		return nil
	case oastypes.FieldOther:
		m.ResetOther()
		return nil
	case oastypes.FieldOptional:
		m.ResetOptional()
		return nil
	case oastypes.FieldNillable:
		m.ResetNillable()
		return nil
	case oastypes.FieldOptionalAndNillable:
		m.ResetOptionalAndNillable()
		return nil
	}
	return fmt.Errorf("unknown OASTypes field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *OASTypesMutation) 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 *OASTypesMutation) AddedIDs(name string) []ent.Value {
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *OASTypesMutation) 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 *OASTypesMutation) RemovedIDs(name string) []ent.Value {
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *OASTypesMutation) 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 *OASTypesMutation) 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 *OASTypesMutation) ClearEdge(name string) error {
	return fmt.Errorf("unknown OASTypes 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 *OASTypesMutation) ResetEdge(name string) error {
	return fmt.Errorf("unknown OASTypes edge %s", name)
}