mutation.go

// Code generated by ent, DO NOT EDIT.

package ent

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

	"entgo.io/ent"
	"entgo.io/ent/dialect/sql"
	v1 "github.com/chainloop-dev/chainloop/app/controlplane/api/controlplane/v1"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/biz"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/integration"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/integrationattachment"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/membership"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/ocirepository"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/organization"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/predicate"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/robotaccount"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/user"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/workflow"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/workflowcontract"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/workflowcontractversion"
	"github.com/chainloop-dev/chainloop/app/controlplane/internal/data/ent/workflowrun"
	"github.com/google/uuid"
)

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

	// Node types.
	TypeIntegration             = "Integration"
	TypeIntegrationAttachment   = "IntegrationAttachment"
	TypeMembership              = "Membership"
	TypeOCIRepository           = "OCIRepository"
	TypeOrganization            = "Organization"
	TypeRobotAccount            = "RobotAccount"
	TypeUser                    = "User"
	TypeWorkflow                = "Workflow"
	TypeWorkflowContract        = "WorkflowContract"
	TypeWorkflowContractVersion = "WorkflowContractVersion"
	TypeWorkflowRun             = "WorkflowRun"
)

// IntegrationMutation represents an operation that mutates the Integration nodes in the graph.
type IntegrationMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	kind                *string
	secret_name         *string
	created_at          *time.Time
	_config             **v1.IntegrationConfig
	deleted_at          *time.Time
	clearedFields       map[string]struct{}
	attachments         map[uuid.UUID]struct{}
	removedattachments  map[uuid.UUID]struct{}
	clearedattachments  bool
	organization        *uuid.UUID
	clearedorganization bool
	done                bool
	oldValue            func(context.Context) (*Integration, error)
	predicates          []predicate.Integration
}

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

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

// newIntegrationMutation creates new mutation for the Integration entity.
func newIntegrationMutation(c config, op Op, opts ...integrationOption) *IntegrationMutation {
	m := &IntegrationMutation{
		config:        c,
		op:            op,
		typ:           TypeIntegration,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withIntegration sets the old Integration of the mutation.
func withIntegration(node *Integration) integrationOption {
	return func(m *IntegrationMutation) {
		m.oldValue = func(context.Context) (*Integration, 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 IntegrationMutation) 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 IntegrationMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Integration entities.
func (m *IntegrationMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *IntegrationMutation) ID() (id uuid.UUID, 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 *IntegrationMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Integration.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetKind sets the "kind" field.
func (m *IntegrationMutation) SetKind(s string) {
	m.kind = &s
}

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

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

// ResetKind resets all changes to the "kind" field.
func (m *IntegrationMutation) ResetKind() {
	m.kind = nil
}

// SetSecretName sets the "secret_name" field.
func (m *IntegrationMutation) SetSecretName(s string) {
	m.secret_name = &s
}

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

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

// ResetSecretName resets all changes to the "secret_name" field.
func (m *IntegrationMutation) ResetSecretName() {
	m.secret_name = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *IntegrationMutation) 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 Integration entity.
// If the Integration 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 *IntegrationMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *IntegrationMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetConfig sets the "config" field.
func (m *IntegrationMutation) SetConfig(vc *v1.IntegrationConfig) {
	m._config = &vc
}

// Config returns the value of the "config" field in the mutation.
func (m *IntegrationMutation) Config() (r *v1.IntegrationConfig, exists bool) {
	v := m._config
	if v == nil {
		return
	}
	return *v, true
}

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

// ResetConfig resets all changes to the "config" field.
func (m *IntegrationMutation) ResetConfig() {
	m._config = nil
}

// SetDeletedAt sets the "deleted_at" field.
func (m *IntegrationMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *IntegrationMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[integration.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *IntegrationMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[integration.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *IntegrationMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, integration.FieldDeletedAt)
}

// AddAttachmentIDs adds the "attachments" edge to the IntegrationAttachment entity by ids.
func (m *IntegrationMutation) AddAttachmentIDs(ids ...uuid.UUID) {
	if m.attachments == nil {
		m.attachments = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.attachments[ids[i]] = struct{}{}
	}
}

// ClearAttachments clears the "attachments" edge to the IntegrationAttachment entity.
func (m *IntegrationMutation) ClearAttachments() {
	m.clearedattachments = true
}

// AttachmentsCleared reports if the "attachments" edge to the IntegrationAttachment entity was cleared.
func (m *IntegrationMutation) AttachmentsCleared() bool {
	return m.clearedattachments
}

// RemoveAttachmentIDs removes the "attachments" edge to the IntegrationAttachment entity by IDs.
func (m *IntegrationMutation) RemoveAttachmentIDs(ids ...uuid.UUID) {
	if m.removedattachments == nil {
		m.removedattachments = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.attachments, ids[i])
		m.removedattachments[ids[i]] = struct{}{}
	}
}

// RemovedAttachments returns the removed IDs of the "attachments" edge to the IntegrationAttachment entity.
func (m *IntegrationMutation) RemovedAttachmentsIDs() (ids []uuid.UUID) {
	for id := range m.removedattachments {
		ids = append(ids, id)
	}
	return
}

// AttachmentsIDs returns the "attachments" edge IDs in the mutation.
func (m *IntegrationMutation) AttachmentsIDs() (ids []uuid.UUID) {
	for id := range m.attachments {
		ids = append(ids, id)
	}
	return
}

// ResetAttachments resets all changes to the "attachments" edge.
func (m *IntegrationMutation) ResetAttachments() {
	m.attachments = nil
	m.clearedattachments = false
	m.removedattachments = nil
}

// SetOrganizationID sets the "organization" edge to the Organization entity by id.
func (m *IntegrationMutation) SetOrganizationID(id uuid.UUID) {
	m.organization = &id
}

// ClearOrganization clears the "organization" edge to the Organization entity.
func (m *IntegrationMutation) ClearOrganization() {
	m.clearedorganization = true
}

// OrganizationCleared reports if the "organization" edge to the Organization entity was cleared.
func (m *IntegrationMutation) OrganizationCleared() bool {
	return m.clearedorganization
}

// OrganizationID returns the "organization" edge ID in the mutation.
func (m *IntegrationMutation) OrganizationID() (id uuid.UUID, exists bool) {
	if m.organization != nil {
		return *m.organization, true
	}
	return
}

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

// ResetOrganization resets all changes to the "organization" edge.
func (m *IntegrationMutation) ResetOrganization() {
	m.organization = nil
	m.clearedorganization = false
}

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

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

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

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

// Type returns the node type of this mutation (Integration).
func (m *IntegrationMutation) 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 *IntegrationMutation) Fields() []string {
	fields := make([]string, 0, 5)
	if m.kind != nil {
		fields = append(fields, integration.FieldKind)
	}
	if m.secret_name != nil {
		fields = append(fields, integration.FieldSecretName)
	}
	if m.created_at != nil {
		fields = append(fields, integration.FieldCreatedAt)
	}
	if m._config != nil {
		fields = append(fields, integration.FieldConfig)
	}
	if m.deleted_at != nil {
		fields = append(fields, integration.FieldDeletedAt)
	}
	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 *IntegrationMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case integration.FieldKind:
		return m.Kind()
	case integration.FieldSecretName:
		return m.SecretName()
	case integration.FieldCreatedAt:
		return m.CreatedAt()
	case integration.FieldConfig:
		return m.Config()
	case integration.FieldDeletedAt:
		return m.DeletedAt()
	}
	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 *IntegrationMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case integration.FieldKind:
		return m.OldKind(ctx)
	case integration.FieldSecretName:
		return m.OldSecretName(ctx)
	case integration.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case integration.FieldConfig:
		return m.OldConfig(ctx)
	case integration.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Integration 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 *IntegrationMutation) SetField(name string, value ent.Value) error {
	switch name {
	case integration.FieldKind:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetKind(v)
		return nil
	case integration.FieldSecretName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSecretName(v)
		return nil
	case integration.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 integration.FieldConfig:
		v, ok := value.(*v1.IntegrationConfig)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConfig(v)
		return nil
	case integration.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Integration field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *IntegrationMutation) 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 *IntegrationMutation) 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 *IntegrationMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Integration numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *IntegrationMutation) 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 *IntegrationMutation) ClearField(name string) error {
	switch name {
	case integration.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Integration 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 *IntegrationMutation) ResetField(name string) error {
	switch name {
	case integration.FieldKind:
		m.ResetKind()
		return nil
	case integration.FieldSecretName:
		m.ResetSecretName()
		return nil
	case integration.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case integration.FieldConfig:
		m.ResetConfig()
		return nil
	case integration.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Integration field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *IntegrationMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.attachments != nil {
		edges = append(edges, integration.EdgeAttachments)
	}
	if m.organization != nil {
		edges = append(edges, integration.EdgeOrganization)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *IntegrationMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case integration.EdgeAttachments:
		ids := make([]ent.Value, 0, len(m.attachments))
		for id := range m.attachments {
			ids = append(ids, id)
		}
		return ids
	case integration.EdgeOrganization:
		if id := m.organization; id != nil {
			return []ent.Value{*id}
		}
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *IntegrationMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedattachments != nil {
		edges = append(edges, integration.EdgeAttachments)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *IntegrationMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case integration.EdgeAttachments:
		ids := make([]ent.Value, 0, len(m.removedattachments))
		for id := range m.removedattachments {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *IntegrationMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedattachments {
		edges = append(edges, integration.EdgeAttachments)
	}
	if m.clearedorganization {
		edges = append(edges, integration.EdgeOrganization)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *IntegrationMutation) EdgeCleared(name string) bool {
	switch name {
	case integration.EdgeAttachments:
		return m.clearedattachments
	case integration.EdgeOrganization:
		return m.clearedorganization
	}
	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 *IntegrationMutation) ClearEdge(name string) error {
	switch name {
	case integration.EdgeOrganization:
		m.ClearOrganization()
		return nil
	}
	return fmt.Errorf("unknown Integration 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 *IntegrationMutation) ResetEdge(name string) error {
	switch name {
	case integration.EdgeAttachments:
		m.ResetAttachments()
		return nil
	case integration.EdgeOrganization:
		m.ResetOrganization()
		return nil
	}
	return fmt.Errorf("unknown Integration edge %s", name)
}

// IntegrationAttachmentMutation represents an operation that mutates the IntegrationAttachment nodes in the graph.
type IntegrationAttachmentMutation struct {
	config
	op                 Op
	typ                string
	id                 *uuid.UUID
	created_at         *time.Time
	_config            **v1.IntegrationAttachmentConfig
	deleted_at         *time.Time
	clearedFields      map[string]struct{}
	integration        *uuid.UUID
	clearedintegration bool
	workflow           *uuid.UUID
	clearedworkflow    bool
	done               bool
	oldValue           func(context.Context) (*IntegrationAttachment, error)
	predicates         []predicate.IntegrationAttachment
}

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

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

// newIntegrationAttachmentMutation creates new mutation for the IntegrationAttachment entity.
func newIntegrationAttachmentMutation(c config, op Op, opts ...integrationattachmentOption) *IntegrationAttachmentMutation {
	m := &IntegrationAttachmentMutation{
		config:        c,
		op:            op,
		typ:           TypeIntegrationAttachment,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withIntegrationAttachment sets the old IntegrationAttachment of the mutation.
func withIntegrationAttachment(node *IntegrationAttachment) integrationattachmentOption {
	return func(m *IntegrationAttachmentMutation) {
		m.oldValue = func(context.Context) (*IntegrationAttachment, 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 IntegrationAttachmentMutation) 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 IntegrationAttachmentMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of IntegrationAttachment entities.
func (m *IntegrationAttachmentMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *IntegrationAttachmentMutation) ID() (id uuid.UUID, 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 *IntegrationAttachmentMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().IntegrationAttachment.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *IntegrationAttachmentMutation) 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 IntegrationAttachment entity.
// If the IntegrationAttachment 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 *IntegrationAttachmentMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *IntegrationAttachmentMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetConfig sets the "config" field.
func (m *IntegrationAttachmentMutation) SetConfig(vac *v1.IntegrationAttachmentConfig) {
	m._config = &vac
}

// Config returns the value of the "config" field in the mutation.
func (m *IntegrationAttachmentMutation) Config() (r *v1.IntegrationAttachmentConfig, exists bool) {
	v := m._config
	if v == nil {
		return
	}
	return *v, true
}

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

// ResetConfig resets all changes to the "config" field.
func (m *IntegrationAttachmentMutation) ResetConfig() {
	m._config = nil
}

// SetDeletedAt sets the "deleted_at" field.
func (m *IntegrationAttachmentMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *IntegrationAttachmentMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[integrationattachment.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *IntegrationAttachmentMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[integrationattachment.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *IntegrationAttachmentMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, integrationattachment.FieldDeletedAt)
}

// SetIntegrationID sets the "integration" edge to the Integration entity by id.
func (m *IntegrationAttachmentMutation) SetIntegrationID(id uuid.UUID) {
	m.integration = &id
}

// ClearIntegration clears the "integration" edge to the Integration entity.
func (m *IntegrationAttachmentMutation) ClearIntegration() {
	m.clearedintegration = true
}

// IntegrationCleared reports if the "integration" edge to the Integration entity was cleared.
func (m *IntegrationAttachmentMutation) IntegrationCleared() bool {
	return m.clearedintegration
}

// IntegrationID returns the "integration" edge ID in the mutation.
func (m *IntegrationAttachmentMutation) IntegrationID() (id uuid.UUID, exists bool) {
	if m.integration != nil {
		return *m.integration, true
	}
	return
}

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

// ResetIntegration resets all changes to the "integration" edge.
func (m *IntegrationAttachmentMutation) ResetIntegration() {
	m.integration = nil
	m.clearedintegration = false
}

// SetWorkflowID sets the "workflow" edge to the Workflow entity by id.
func (m *IntegrationAttachmentMutation) SetWorkflowID(id uuid.UUID) {
	m.workflow = &id
}

// ClearWorkflow clears the "workflow" edge to the Workflow entity.
func (m *IntegrationAttachmentMutation) ClearWorkflow() {
	m.clearedworkflow = true
}

// WorkflowCleared reports if the "workflow" edge to the Workflow entity was cleared.
func (m *IntegrationAttachmentMutation) WorkflowCleared() bool {
	return m.clearedworkflow
}

// WorkflowID returns the "workflow" edge ID in the mutation.
func (m *IntegrationAttachmentMutation) WorkflowID() (id uuid.UUID, exists bool) {
	if m.workflow != nil {
		return *m.workflow, true
	}
	return
}

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

// ResetWorkflow resets all changes to the "workflow" edge.
func (m *IntegrationAttachmentMutation) ResetWorkflow() {
	m.workflow = nil
	m.clearedworkflow = false
}

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

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

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

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

// Type returns the node type of this mutation (IntegrationAttachment).
func (m *IntegrationAttachmentMutation) 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 *IntegrationAttachmentMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.created_at != nil {
		fields = append(fields, integrationattachment.FieldCreatedAt)
	}
	if m._config != nil {
		fields = append(fields, integrationattachment.FieldConfig)
	}
	if m.deleted_at != nil {
		fields = append(fields, integrationattachment.FieldDeletedAt)
	}
	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 *IntegrationAttachmentMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case integrationattachment.FieldCreatedAt:
		return m.CreatedAt()
	case integrationattachment.FieldConfig:
		return m.Config()
	case integrationattachment.FieldDeletedAt:
		return m.DeletedAt()
	}
	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 *IntegrationAttachmentMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case integrationattachment.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case integrationattachment.FieldConfig:
		return m.OldConfig(ctx)
	case integrationattachment.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	}
	return nil, fmt.Errorf("unknown IntegrationAttachment 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 *IntegrationAttachmentMutation) SetField(name string, value ent.Value) error {
	switch name {
	case integrationattachment.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 integrationattachment.FieldConfig:
		v, ok := value.(*v1.IntegrationAttachmentConfig)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetConfig(v)
		return nil
	case integrationattachment.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown IntegrationAttachment field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *IntegrationAttachmentMutation) 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 *IntegrationAttachmentMutation) 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 *IntegrationAttachmentMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown IntegrationAttachment numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *IntegrationAttachmentMutation) 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 *IntegrationAttachmentMutation) ClearField(name string) error {
	switch name {
	case integrationattachment.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown IntegrationAttachment 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 *IntegrationAttachmentMutation) ResetField(name string) error {
	switch name {
	case integrationattachment.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case integrationattachment.FieldConfig:
		m.ResetConfig()
		return nil
	case integrationattachment.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown IntegrationAttachment field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *IntegrationAttachmentMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.integration != nil {
		edges = append(edges, integrationattachment.EdgeIntegration)
	}
	if m.workflow != nil {
		edges = append(edges, integrationattachment.EdgeWorkflow)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *IntegrationAttachmentMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedintegration {
		edges = append(edges, integrationattachment.EdgeIntegration)
	}
	if m.clearedworkflow {
		edges = append(edges, integrationattachment.EdgeWorkflow)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *IntegrationAttachmentMutation) EdgeCleared(name string) bool {
	switch name {
	case integrationattachment.EdgeIntegration:
		return m.clearedintegration
	case integrationattachment.EdgeWorkflow:
		return m.clearedworkflow
	}
	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 *IntegrationAttachmentMutation) ClearEdge(name string) error {
	switch name {
	case integrationattachment.EdgeIntegration:
		m.ClearIntegration()
		return nil
	case integrationattachment.EdgeWorkflow:
		m.ClearWorkflow()
		return nil
	}
	return fmt.Errorf("unknown IntegrationAttachment 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 *IntegrationAttachmentMutation) ResetEdge(name string) error {
	switch name {
	case integrationattachment.EdgeIntegration:
		m.ResetIntegration()
		return nil
	case integrationattachment.EdgeWorkflow:
		m.ResetWorkflow()
		return nil
	}
	return fmt.Errorf("unknown IntegrationAttachment edge %s", name)
}

// MembershipMutation represents an operation that mutates the Membership nodes in the graph.
type MembershipMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	current             *bool
	created_at          *time.Time
	updated_at          *time.Time
	clearedFields       map[string]struct{}
	organization        *uuid.UUID
	clearedorganization bool
	user                *uuid.UUID
	cleareduser         bool
	done                bool
	oldValue            func(context.Context) (*Membership, error)
	predicates          []predicate.Membership
}

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

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

// newMembershipMutation creates new mutation for the Membership entity.
func newMembershipMutation(c config, op Op, opts ...membershipOption) *MembershipMutation {
	m := &MembershipMutation{
		config:        c,
		op:            op,
		typ:           TypeMembership,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withMembership sets the old Membership of the mutation.
func withMembership(node *Membership) membershipOption {
	return func(m *MembershipMutation) {
		m.oldValue = func(context.Context) (*Membership, 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 MembershipMutation) 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 MembershipMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Membership entities.
func (m *MembershipMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *MembershipMutation) ID() (id uuid.UUID, 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 *MembershipMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Membership.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetCurrent sets the "current" field.
func (m *MembershipMutation) SetCurrent(b bool) {
	m.current = &b
}

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

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

// ResetCurrent resets all changes to the "current" field.
func (m *MembershipMutation) ResetCurrent() {
	m.current = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *MembershipMutation) 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 Membership entity.
// If the Membership 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 *MembershipMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *MembershipMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetUpdatedAt sets the "updated_at" field.
func (m *MembershipMutation) SetUpdatedAt(t time.Time) {
	m.updated_at = &t
}

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

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

// ResetUpdatedAt resets all changes to the "updated_at" field.
func (m *MembershipMutation) ResetUpdatedAt() {
	m.updated_at = nil
}

// SetOrganizationID sets the "organization" edge to the Organization entity by id.
func (m *MembershipMutation) SetOrganizationID(id uuid.UUID) {
	m.organization = &id
}

// ClearOrganization clears the "organization" edge to the Organization entity.
func (m *MembershipMutation) ClearOrganization() {
	m.clearedorganization = true
}

// OrganizationCleared reports if the "organization" edge to the Organization entity was cleared.
func (m *MembershipMutation) OrganizationCleared() bool {
	return m.clearedorganization
}

// OrganizationID returns the "organization" edge ID in the mutation.
func (m *MembershipMutation) OrganizationID() (id uuid.UUID, exists bool) {
	if m.organization != nil {
		return *m.organization, true
	}
	return
}

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

// ResetOrganization resets all changes to the "organization" edge.
func (m *MembershipMutation) ResetOrganization() {
	m.organization = nil
	m.clearedorganization = false
}

// SetUserID sets the "user" edge to the User entity by id.
func (m *MembershipMutation) SetUserID(id uuid.UUID) {
	m.user = &id
}

// ClearUser clears the "user" edge to the User entity.
func (m *MembershipMutation) ClearUser() {
	m.cleareduser = true
}

// UserCleared reports if the "user" edge to the User entity was cleared.
func (m *MembershipMutation) UserCleared() bool {
	return m.cleareduser
}

// UserID returns the "user" edge ID in the mutation.
func (m *MembershipMutation) UserID() (id uuid.UUID, exists bool) {
	if m.user != nil {
		return *m.user, true
	}
	return
}

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

// ResetUser resets all changes to the "user" edge.
func (m *MembershipMutation) ResetUser() {
	m.user = nil
	m.cleareduser = false
}

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

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

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

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

// Type returns the node type of this mutation (Membership).
func (m *MembershipMutation) 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 *MembershipMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.current != nil {
		fields = append(fields, membership.FieldCurrent)
	}
	if m.created_at != nil {
		fields = append(fields, membership.FieldCreatedAt)
	}
	if m.updated_at != nil {
		fields = append(fields, membership.FieldUpdatedAt)
	}
	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 *MembershipMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case membership.FieldCurrent:
		return m.Current()
	case membership.FieldCreatedAt:
		return m.CreatedAt()
	case membership.FieldUpdatedAt:
		return m.UpdatedAt()
	}
	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 *MembershipMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case membership.FieldCurrent:
		return m.OldCurrent(ctx)
	case membership.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case membership.FieldUpdatedAt:
		return m.OldUpdatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Membership 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 *MembershipMutation) SetField(name string, value ent.Value) error {
	switch name {
	case membership.FieldCurrent:
		v, ok := value.(bool)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCurrent(v)
		return nil
	case membership.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 membership.FieldUpdatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetUpdatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Membership field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *MembershipMutation) 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 *MembershipMutation) 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 *MembershipMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Membership numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *MembershipMutation) 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 *MembershipMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Membership 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 *MembershipMutation) ResetField(name string) error {
	switch name {
	case membership.FieldCurrent:
		m.ResetCurrent()
		return nil
	case membership.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case membership.FieldUpdatedAt:
		m.ResetUpdatedAt()
		return nil
	}
	return fmt.Errorf("unknown Membership field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *MembershipMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.organization != nil {
		edges = append(edges, membership.EdgeOrganization)
	}
	if m.user != nil {
		edges = append(edges, membership.EdgeUser)
	}
	return edges
}

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

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *MembershipMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedorganization {
		edges = append(edges, membership.EdgeOrganization)
	}
	if m.cleareduser {
		edges = append(edges, membership.EdgeUser)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *MembershipMutation) EdgeCleared(name string) bool {
	switch name {
	case membership.EdgeOrganization:
		return m.clearedorganization
	case membership.EdgeUser:
		return m.cleareduser
	}
	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 *MembershipMutation) ClearEdge(name string) error {
	switch name {
	case membership.EdgeOrganization:
		m.ClearOrganization()
		return nil
	case membership.EdgeUser:
		m.ClearUser()
		return nil
	}
	return fmt.Errorf("unknown Membership 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 *MembershipMutation) ResetEdge(name string) error {
	switch name {
	case membership.EdgeOrganization:
		m.ResetOrganization()
		return nil
	case membership.EdgeUser:
		m.ResetUser()
		return nil
	}
	return fmt.Errorf("unknown Membership edge %s", name)
}

// OCIRepositoryMutation represents an operation that mutates the OCIRepository nodes in the graph.
type OCIRepositoryMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	repo                *string
	secret_name         *string
	created_at          *time.Time
	validation_status   *biz.OCIRepoValidationStatus
	validated_at        *time.Time
	clearedFields       map[string]struct{}
	organization        *uuid.UUID
	clearedorganization bool
	done                bool
	oldValue            func(context.Context) (*OCIRepository, error)
	predicates          []predicate.OCIRepository
}

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

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

// newOCIRepositoryMutation creates new mutation for the OCIRepository entity.
func newOCIRepositoryMutation(c config, op Op, opts ...ocirepositoryOption) *OCIRepositoryMutation {
	m := &OCIRepositoryMutation{
		config:        c,
		op:            op,
		typ:           TypeOCIRepository,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withOCIRepository sets the old OCIRepository of the mutation.
func withOCIRepository(node *OCIRepository) ocirepositoryOption {
	return func(m *OCIRepositoryMutation) {
		m.oldValue = func(context.Context) (*OCIRepository, 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 OCIRepositoryMutation) 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 OCIRepositoryMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of OCIRepository entities.
func (m *OCIRepositoryMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *OCIRepositoryMutation) ID() (id uuid.UUID, 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 *OCIRepositoryMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().OCIRepository.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetRepo sets the "repo" field.
func (m *OCIRepositoryMutation) SetRepo(s string) {
	m.repo = &s
}

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

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

// ResetRepo resets all changes to the "repo" field.
func (m *OCIRepositoryMutation) ResetRepo() {
	m.repo = nil
}

// SetSecretName sets the "secret_name" field.
func (m *OCIRepositoryMutation) SetSecretName(s string) {
	m.secret_name = &s
}

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

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

// ResetSecretName resets all changes to the "secret_name" field.
func (m *OCIRepositoryMutation) ResetSecretName() {
	m.secret_name = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *OCIRepositoryMutation) 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 OCIRepository entity.
// If the OCIRepository 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 *OCIRepositoryMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *OCIRepositoryMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetValidationStatus sets the "validation_status" field.
func (m *OCIRepositoryMutation) SetValidationStatus(brvs biz.OCIRepoValidationStatus) {
	m.validation_status = &brvs
}

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

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

// ResetValidationStatus resets all changes to the "validation_status" field.
func (m *OCIRepositoryMutation) ResetValidationStatus() {
	m.validation_status = nil
}

// SetValidatedAt sets the "validated_at" field.
func (m *OCIRepositoryMutation) SetValidatedAt(t time.Time) {
	m.validated_at = &t
}

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

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

// ResetValidatedAt resets all changes to the "validated_at" field.
func (m *OCIRepositoryMutation) ResetValidatedAt() {
	m.validated_at = nil
}

// SetOrganizationID sets the "organization" edge to the Organization entity by id.
func (m *OCIRepositoryMutation) SetOrganizationID(id uuid.UUID) {
	m.organization = &id
}

// ClearOrganization clears the "organization" edge to the Organization entity.
func (m *OCIRepositoryMutation) ClearOrganization() {
	m.clearedorganization = true
}

// OrganizationCleared reports if the "organization" edge to the Organization entity was cleared.
func (m *OCIRepositoryMutation) OrganizationCleared() bool {
	return m.clearedorganization
}

// OrganizationID returns the "organization" edge ID in the mutation.
func (m *OCIRepositoryMutation) OrganizationID() (id uuid.UUID, exists bool) {
	if m.organization != nil {
		return *m.organization, true
	}
	return
}

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

// ResetOrganization resets all changes to the "organization" edge.
func (m *OCIRepositoryMutation) ResetOrganization() {
	m.organization = nil
	m.clearedorganization = false
}

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

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

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

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

// Type returns the node type of this mutation (OCIRepository).
func (m *OCIRepositoryMutation) 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 *OCIRepositoryMutation) Fields() []string {
	fields := make([]string, 0, 5)
	if m.repo != nil {
		fields = append(fields, ocirepository.FieldRepo)
	}
	if m.secret_name != nil {
		fields = append(fields, ocirepository.FieldSecretName)
	}
	if m.created_at != nil {
		fields = append(fields, ocirepository.FieldCreatedAt)
	}
	if m.validation_status != nil {
		fields = append(fields, ocirepository.FieldValidationStatus)
	}
	if m.validated_at != nil {
		fields = append(fields, ocirepository.FieldValidatedAt)
	}
	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 *OCIRepositoryMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case ocirepository.FieldRepo:
		return m.Repo()
	case ocirepository.FieldSecretName:
		return m.SecretName()
	case ocirepository.FieldCreatedAt:
		return m.CreatedAt()
	case ocirepository.FieldValidationStatus:
		return m.ValidationStatus()
	case ocirepository.FieldValidatedAt:
		return m.ValidatedAt()
	}
	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 *OCIRepositoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case ocirepository.FieldRepo:
		return m.OldRepo(ctx)
	case ocirepository.FieldSecretName:
		return m.OldSecretName(ctx)
	case ocirepository.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case ocirepository.FieldValidationStatus:
		return m.OldValidationStatus(ctx)
	case ocirepository.FieldValidatedAt:
		return m.OldValidatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown OCIRepository 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 *OCIRepositoryMutation) SetField(name string, value ent.Value) error {
	switch name {
	case ocirepository.FieldRepo:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRepo(v)
		return nil
	case ocirepository.FieldSecretName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetSecretName(v)
		return nil
	case ocirepository.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 ocirepository.FieldValidationStatus:
		v, ok := value.(biz.OCIRepoValidationStatus)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetValidationStatus(v)
		return nil
	case ocirepository.FieldValidatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetValidatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown OCIRepository field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OCIRepositoryMutation) 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 *OCIRepositoryMutation) 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 *OCIRepositoryMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown OCIRepository numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OCIRepositoryMutation) 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 *OCIRepositoryMutation) ClearField(name string) error {
	return fmt.Errorf("unknown OCIRepository 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 *OCIRepositoryMutation) ResetField(name string) error {
	switch name {
	case ocirepository.FieldRepo:
		m.ResetRepo()
		return nil
	case ocirepository.FieldSecretName:
		m.ResetSecretName()
		return nil
	case ocirepository.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case ocirepository.FieldValidationStatus:
		m.ResetValidationStatus()
		return nil
	case ocirepository.FieldValidatedAt:
		m.ResetValidatedAt()
		return nil
	}
	return fmt.Errorf("unknown OCIRepository field %s", name)
}

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *OCIRepositoryMutation) EdgeCleared(name string) bool {
	switch name {
	case ocirepository.EdgeOrganization:
		return m.clearedorganization
	}
	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 *OCIRepositoryMutation) ClearEdge(name string) error {
	switch name {
	case ocirepository.EdgeOrganization:
		m.ClearOrganization()
		return nil
	}
	return fmt.Errorf("unknown OCIRepository 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 *OCIRepositoryMutation) ResetEdge(name string) error {
	switch name {
	case ocirepository.EdgeOrganization:
		m.ResetOrganization()
		return nil
	}
	return fmt.Errorf("unknown OCIRepository edge %s", name)
}

// OrganizationMutation represents an operation that mutates the Organization nodes in the graph.
type OrganizationMutation struct {
	config
	op                        Op
	typ                       string
	id                        *uuid.UUID
	name                      *string
	created_at                *time.Time
	clearedFields             map[string]struct{}
	memberships               map[uuid.UUID]struct{}
	removedmemberships        map[uuid.UUID]struct{}
	clearedmemberships        bool
	workflow_contracts        map[uuid.UUID]struct{}
	removedworkflow_contracts map[uuid.UUID]struct{}
	clearedworkflow_contracts bool
	workflows                 map[uuid.UUID]struct{}
	removedworkflows          map[uuid.UUID]struct{}
	clearedworkflows          bool
	oci_repositories          map[uuid.UUID]struct{}
	removedoci_repositories   map[uuid.UUID]struct{}
	clearedoci_repositories   bool
	integrations              map[uuid.UUID]struct{}
	removedintegrations       map[uuid.UUID]struct{}
	clearedintegrations       bool
	done                      bool
	oldValue                  func(context.Context) (*Organization, error)
	predicates                []predicate.Organization
}

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

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

// newOrganizationMutation creates new mutation for the Organization entity.
func newOrganizationMutation(c config, op Op, opts ...organizationOption) *OrganizationMutation {
	m := &OrganizationMutation{
		config:        c,
		op:            op,
		typ:           TypeOrganization,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withOrganization sets the old Organization of the mutation.
func withOrganization(node *Organization) organizationOption {
	return func(m *OrganizationMutation) {
		m.oldValue = func(context.Context) (*Organization, 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 OrganizationMutation) 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 OrganizationMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Organization entities.
func (m *OrganizationMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *OrganizationMutation) ID() (id uuid.UUID, 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 *OrganizationMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Organization.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// Name returns the value of the "name" field in the mutation.
func (m *OrganizationMutation) 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 Organization entity.
// If the Organization 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 *OrganizationMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *OrganizationMutation) ResetName() {
	m.name = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *OrganizationMutation) 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 Organization entity.
// If the Organization 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 *OrganizationMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *OrganizationMutation) ResetCreatedAt() {
	m.created_at = nil
}

// AddMembershipIDs adds the "memberships" edge to the Membership entity by ids.
func (m *OrganizationMutation) AddMembershipIDs(ids ...uuid.UUID) {
	if m.memberships == nil {
		m.memberships = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.memberships[ids[i]] = struct{}{}
	}
}

// ClearMemberships clears the "memberships" edge to the Membership entity.
func (m *OrganizationMutation) ClearMemberships() {
	m.clearedmemberships = true
}

// MembershipsCleared reports if the "memberships" edge to the Membership entity was cleared.
func (m *OrganizationMutation) MembershipsCleared() bool {
	return m.clearedmemberships
}

// RemoveMembershipIDs removes the "memberships" edge to the Membership entity by IDs.
func (m *OrganizationMutation) RemoveMembershipIDs(ids ...uuid.UUID) {
	if m.removedmemberships == nil {
		m.removedmemberships = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.memberships, ids[i])
		m.removedmemberships[ids[i]] = struct{}{}
	}
}

// RemovedMemberships returns the removed IDs of the "memberships" edge to the Membership entity.
func (m *OrganizationMutation) RemovedMembershipsIDs() (ids []uuid.UUID) {
	for id := range m.removedmemberships {
		ids = append(ids, id)
	}
	return
}

// MembershipsIDs returns the "memberships" edge IDs in the mutation.
func (m *OrganizationMutation) MembershipsIDs() (ids []uuid.UUID) {
	for id := range m.memberships {
		ids = append(ids, id)
	}
	return
}

// ResetMemberships resets all changes to the "memberships" edge.
func (m *OrganizationMutation) ResetMemberships() {
	m.memberships = nil
	m.clearedmemberships = false
	m.removedmemberships = nil
}

// AddWorkflowContractIDs adds the "workflow_contracts" edge to the WorkflowContract entity by ids.
func (m *OrganizationMutation) AddWorkflowContractIDs(ids ...uuid.UUID) {
	if m.workflow_contracts == nil {
		m.workflow_contracts = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.workflow_contracts[ids[i]] = struct{}{}
	}
}

// ClearWorkflowContracts clears the "workflow_contracts" edge to the WorkflowContract entity.
func (m *OrganizationMutation) ClearWorkflowContracts() {
	m.clearedworkflow_contracts = true
}

// WorkflowContractsCleared reports if the "workflow_contracts" edge to the WorkflowContract entity was cleared.
func (m *OrganizationMutation) WorkflowContractsCleared() bool {
	return m.clearedworkflow_contracts
}

// RemoveWorkflowContractIDs removes the "workflow_contracts" edge to the WorkflowContract entity by IDs.
func (m *OrganizationMutation) RemoveWorkflowContractIDs(ids ...uuid.UUID) {
	if m.removedworkflow_contracts == nil {
		m.removedworkflow_contracts = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.workflow_contracts, ids[i])
		m.removedworkflow_contracts[ids[i]] = struct{}{}
	}
}

// RemovedWorkflowContracts returns the removed IDs of the "workflow_contracts" edge to the WorkflowContract entity.
func (m *OrganizationMutation) RemovedWorkflowContractsIDs() (ids []uuid.UUID) {
	for id := range m.removedworkflow_contracts {
		ids = append(ids, id)
	}
	return
}

// WorkflowContractsIDs returns the "workflow_contracts" edge IDs in the mutation.
func (m *OrganizationMutation) WorkflowContractsIDs() (ids []uuid.UUID) {
	for id := range m.workflow_contracts {
		ids = append(ids, id)
	}
	return
}

// ResetWorkflowContracts resets all changes to the "workflow_contracts" edge.
func (m *OrganizationMutation) ResetWorkflowContracts() {
	m.workflow_contracts = nil
	m.clearedworkflow_contracts = false
	m.removedworkflow_contracts = nil
}

// AddWorkflowIDs adds the "workflows" edge to the Workflow entity by ids.
func (m *OrganizationMutation) AddWorkflowIDs(ids ...uuid.UUID) {
	if m.workflows == nil {
		m.workflows = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.workflows[ids[i]] = struct{}{}
	}
}

// ClearWorkflows clears the "workflows" edge to the Workflow entity.
func (m *OrganizationMutation) ClearWorkflows() {
	m.clearedworkflows = true
}

// WorkflowsCleared reports if the "workflows" edge to the Workflow entity was cleared.
func (m *OrganizationMutation) WorkflowsCleared() bool {
	return m.clearedworkflows
}

// RemoveWorkflowIDs removes the "workflows" edge to the Workflow entity by IDs.
func (m *OrganizationMutation) RemoveWorkflowIDs(ids ...uuid.UUID) {
	if m.removedworkflows == nil {
		m.removedworkflows = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.workflows, ids[i])
		m.removedworkflows[ids[i]] = struct{}{}
	}
}

// RemovedWorkflows returns the removed IDs of the "workflows" edge to the Workflow entity.
func (m *OrganizationMutation) RemovedWorkflowsIDs() (ids []uuid.UUID) {
	for id := range m.removedworkflows {
		ids = append(ids, id)
	}
	return
}

// WorkflowsIDs returns the "workflows" edge IDs in the mutation.
func (m *OrganizationMutation) WorkflowsIDs() (ids []uuid.UUID) {
	for id := range m.workflows {
		ids = append(ids, id)
	}
	return
}

// ResetWorkflows resets all changes to the "workflows" edge.
func (m *OrganizationMutation) ResetWorkflows() {
	m.workflows = nil
	m.clearedworkflows = false
	m.removedworkflows = nil
}

// AddOciRepositoryIDs adds the "oci_repositories" edge to the OCIRepository entity by ids.
func (m *OrganizationMutation) AddOciRepositoryIDs(ids ...uuid.UUID) {
	if m.oci_repositories == nil {
		m.oci_repositories = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.oci_repositories[ids[i]] = struct{}{}
	}
}

// ClearOciRepositories clears the "oci_repositories" edge to the OCIRepository entity.
func (m *OrganizationMutation) ClearOciRepositories() {
	m.clearedoci_repositories = true
}

// OciRepositoriesCleared reports if the "oci_repositories" edge to the OCIRepository entity was cleared.
func (m *OrganizationMutation) OciRepositoriesCleared() bool {
	return m.clearedoci_repositories
}

// RemoveOciRepositoryIDs removes the "oci_repositories" edge to the OCIRepository entity by IDs.
func (m *OrganizationMutation) RemoveOciRepositoryIDs(ids ...uuid.UUID) {
	if m.removedoci_repositories == nil {
		m.removedoci_repositories = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.oci_repositories, ids[i])
		m.removedoci_repositories[ids[i]] = struct{}{}
	}
}

// RemovedOciRepositories returns the removed IDs of the "oci_repositories" edge to the OCIRepository entity.
func (m *OrganizationMutation) RemovedOciRepositoriesIDs() (ids []uuid.UUID) {
	for id := range m.removedoci_repositories {
		ids = append(ids, id)
	}
	return
}

// OciRepositoriesIDs returns the "oci_repositories" edge IDs in the mutation.
func (m *OrganizationMutation) OciRepositoriesIDs() (ids []uuid.UUID) {
	for id := range m.oci_repositories {
		ids = append(ids, id)
	}
	return
}

// ResetOciRepositories resets all changes to the "oci_repositories" edge.
func (m *OrganizationMutation) ResetOciRepositories() {
	m.oci_repositories = nil
	m.clearedoci_repositories = false
	m.removedoci_repositories = nil
}

// AddIntegrationIDs adds the "integrations" edge to the Integration entity by ids.
func (m *OrganizationMutation) AddIntegrationIDs(ids ...uuid.UUID) {
	if m.integrations == nil {
		m.integrations = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.integrations[ids[i]] = struct{}{}
	}
}

// ClearIntegrations clears the "integrations" edge to the Integration entity.
func (m *OrganizationMutation) ClearIntegrations() {
	m.clearedintegrations = true
}

// IntegrationsCleared reports if the "integrations" edge to the Integration entity was cleared.
func (m *OrganizationMutation) IntegrationsCleared() bool {
	return m.clearedintegrations
}

// RemoveIntegrationIDs removes the "integrations" edge to the Integration entity by IDs.
func (m *OrganizationMutation) RemoveIntegrationIDs(ids ...uuid.UUID) {
	if m.removedintegrations == nil {
		m.removedintegrations = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.integrations, ids[i])
		m.removedintegrations[ids[i]] = struct{}{}
	}
}

// RemovedIntegrations returns the removed IDs of the "integrations" edge to the Integration entity.
func (m *OrganizationMutation) RemovedIntegrationsIDs() (ids []uuid.UUID) {
	for id := range m.removedintegrations {
		ids = append(ids, id)
	}
	return
}

// IntegrationsIDs returns the "integrations" edge IDs in the mutation.
func (m *OrganizationMutation) IntegrationsIDs() (ids []uuid.UUID) {
	for id := range m.integrations {
		ids = append(ids, id)
	}
	return
}

// ResetIntegrations resets all changes to the "integrations" edge.
func (m *OrganizationMutation) ResetIntegrations() {
	m.integrations = nil
	m.clearedintegrations = false
	m.removedintegrations = nil
}

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

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

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

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

// Type returns the node type of this mutation (Organization).
func (m *OrganizationMutation) 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 *OrganizationMutation) Fields() []string {
	fields := make([]string, 0, 2)
	if m.name != nil {
		fields = append(fields, organization.FieldName)
	}
	if m.created_at != nil {
		fields = append(fields, organization.FieldCreatedAt)
	}
	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 *OrganizationMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case organization.FieldName:
		return m.Name()
	case organization.FieldCreatedAt:
		return m.CreatedAt()
	}
	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 *OrganizationMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case organization.FieldName:
		return m.OldName(ctx)
	case organization.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Organization 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 *OrganizationMutation) SetField(name string, value ent.Value) error {
	switch name {
	case organization.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case organization.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Organization field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) 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 *OrganizationMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown Organization numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *OrganizationMutation) 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 *OrganizationMutation) ClearField(name string) error {
	return fmt.Errorf("unknown Organization 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 *OrganizationMutation) ResetField(name string) error {
	switch name {
	case organization.FieldName:
		m.ResetName()
		return nil
	case organization.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	}
	return fmt.Errorf("unknown Organization field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *OrganizationMutation) AddedEdges() []string {
	edges := make([]string, 0, 5)
	if m.memberships != nil {
		edges = append(edges, organization.EdgeMemberships)
	}
	if m.workflow_contracts != nil {
		edges = append(edges, organization.EdgeWorkflowContracts)
	}
	if m.workflows != nil {
		edges = append(edges, organization.EdgeWorkflows)
	}
	if m.oci_repositories != nil {
		edges = append(edges, organization.EdgeOciRepositories)
	}
	if m.integrations != nil {
		edges = append(edges, organization.EdgeIntegrations)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *OrganizationMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case organization.EdgeMemberships:
		ids := make([]ent.Value, 0, len(m.memberships))
		for id := range m.memberships {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeWorkflowContracts:
		ids := make([]ent.Value, 0, len(m.workflow_contracts))
		for id := range m.workflow_contracts {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeWorkflows:
		ids := make([]ent.Value, 0, len(m.workflows))
		for id := range m.workflows {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeOciRepositories:
		ids := make([]ent.Value, 0, len(m.oci_repositories))
		for id := range m.oci_repositories {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeIntegrations:
		ids := make([]ent.Value, 0, len(m.integrations))
		for id := range m.integrations {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *OrganizationMutation) RemovedEdges() []string {
	edges := make([]string, 0, 5)
	if m.removedmemberships != nil {
		edges = append(edges, organization.EdgeMemberships)
	}
	if m.removedworkflow_contracts != nil {
		edges = append(edges, organization.EdgeWorkflowContracts)
	}
	if m.removedworkflows != nil {
		edges = append(edges, organization.EdgeWorkflows)
	}
	if m.removedoci_repositories != nil {
		edges = append(edges, organization.EdgeOciRepositories)
	}
	if m.removedintegrations != nil {
		edges = append(edges, organization.EdgeIntegrations)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *OrganizationMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case organization.EdgeMemberships:
		ids := make([]ent.Value, 0, len(m.removedmemberships))
		for id := range m.removedmemberships {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeWorkflowContracts:
		ids := make([]ent.Value, 0, len(m.removedworkflow_contracts))
		for id := range m.removedworkflow_contracts {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeWorkflows:
		ids := make([]ent.Value, 0, len(m.removedworkflows))
		for id := range m.removedworkflows {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeOciRepositories:
		ids := make([]ent.Value, 0, len(m.removedoci_repositories))
		for id := range m.removedoci_repositories {
			ids = append(ids, id)
		}
		return ids
	case organization.EdgeIntegrations:
		ids := make([]ent.Value, 0, len(m.removedintegrations))
		for id := range m.removedintegrations {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *OrganizationMutation) ClearedEdges() []string {
	edges := make([]string, 0, 5)
	if m.clearedmemberships {
		edges = append(edges, organization.EdgeMemberships)
	}
	if m.clearedworkflow_contracts {
		edges = append(edges, organization.EdgeWorkflowContracts)
	}
	if m.clearedworkflows {
		edges = append(edges, organization.EdgeWorkflows)
	}
	if m.clearedoci_repositories {
		edges = append(edges, organization.EdgeOciRepositories)
	}
	if m.clearedintegrations {
		edges = append(edges, organization.EdgeIntegrations)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *OrganizationMutation) EdgeCleared(name string) bool {
	switch name {
	case organization.EdgeMemberships:
		return m.clearedmemberships
	case organization.EdgeWorkflowContracts:
		return m.clearedworkflow_contracts
	case organization.EdgeWorkflows:
		return m.clearedworkflows
	case organization.EdgeOciRepositories:
		return m.clearedoci_repositories
	case organization.EdgeIntegrations:
		return m.clearedintegrations
	}
	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 *OrganizationMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown Organization 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 *OrganizationMutation) ResetEdge(name string) error {
	switch name {
	case organization.EdgeMemberships:
		m.ResetMemberships()
		return nil
	case organization.EdgeWorkflowContracts:
		m.ResetWorkflowContracts()
		return nil
	case organization.EdgeWorkflows:
		m.ResetWorkflows()
		return nil
	case organization.EdgeOciRepositories:
		m.ResetOciRepositories()
		return nil
	case organization.EdgeIntegrations:
		m.ResetIntegrations()
		return nil
	}
	return fmt.Errorf("unknown Organization edge %s", name)
}

// RobotAccountMutation represents an operation that mutates the RobotAccount nodes in the graph.
type RobotAccountMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	name                *string
	created_at          *time.Time
	revoked_at          *time.Time
	clearedFields       map[string]struct{}
	workflow            *uuid.UUID
	clearedworkflow     bool
	workflowruns        map[uuid.UUID]struct{}
	removedworkflowruns map[uuid.UUID]struct{}
	clearedworkflowruns bool
	done                bool
	oldValue            func(context.Context) (*RobotAccount, error)
	predicates          []predicate.RobotAccount
}

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

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

// newRobotAccountMutation creates new mutation for the RobotAccount entity.
func newRobotAccountMutation(c config, op Op, opts ...robotaccountOption) *RobotAccountMutation {
	m := &RobotAccountMutation{
		config:        c,
		op:            op,
		typ:           TypeRobotAccount,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withRobotAccount sets the old RobotAccount of the mutation.
func withRobotAccount(node *RobotAccount) robotaccountOption {
	return func(m *RobotAccountMutation) {
		m.oldValue = func(context.Context) (*RobotAccount, 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 RobotAccountMutation) 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 RobotAccountMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of RobotAccount entities.
func (m *RobotAccountMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *RobotAccountMutation) ID() (id uuid.UUID, 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 *RobotAccountMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().RobotAccount.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// Name returns the value of the "name" field in the mutation.
func (m *RobotAccountMutation) 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 RobotAccount entity.
// If the RobotAccount 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 *RobotAccountMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *RobotAccountMutation) ResetName() {
	m.name = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *RobotAccountMutation) 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 RobotAccount entity.
// If the RobotAccount 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 *RobotAccountMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *RobotAccountMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetRevokedAt sets the "revoked_at" field.
func (m *RobotAccountMutation) SetRevokedAt(t time.Time) {
	m.revoked_at = &t
}

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

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

// ClearRevokedAt clears the value of the "revoked_at" field.
func (m *RobotAccountMutation) ClearRevokedAt() {
	m.revoked_at = nil
	m.clearedFields[robotaccount.FieldRevokedAt] = struct{}{}
}

// RevokedAtCleared returns if the "revoked_at" field was cleared in this mutation.
func (m *RobotAccountMutation) RevokedAtCleared() bool {
	_, ok := m.clearedFields[robotaccount.FieldRevokedAt]
	return ok
}

// ResetRevokedAt resets all changes to the "revoked_at" field.
func (m *RobotAccountMutation) ResetRevokedAt() {
	m.revoked_at = nil
	delete(m.clearedFields, robotaccount.FieldRevokedAt)
}

// SetWorkflowID sets the "workflow" edge to the Workflow entity by id.
func (m *RobotAccountMutation) SetWorkflowID(id uuid.UUID) {
	m.workflow = &id
}

// ClearWorkflow clears the "workflow" edge to the Workflow entity.
func (m *RobotAccountMutation) ClearWorkflow() {
	m.clearedworkflow = true
}

// WorkflowCleared reports if the "workflow" edge to the Workflow entity was cleared.
func (m *RobotAccountMutation) WorkflowCleared() bool {
	return m.clearedworkflow
}

// WorkflowID returns the "workflow" edge ID in the mutation.
func (m *RobotAccountMutation) WorkflowID() (id uuid.UUID, exists bool) {
	if m.workflow != nil {
		return *m.workflow, true
	}
	return
}

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

// ResetWorkflow resets all changes to the "workflow" edge.
func (m *RobotAccountMutation) ResetWorkflow() {
	m.workflow = nil
	m.clearedworkflow = false
}

// AddWorkflowrunIDs adds the "workflowruns" edge to the WorkflowRun entity by ids.
func (m *RobotAccountMutation) AddWorkflowrunIDs(ids ...uuid.UUID) {
	if m.workflowruns == nil {
		m.workflowruns = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.workflowruns[ids[i]] = struct{}{}
	}
}

// ClearWorkflowruns clears the "workflowruns" edge to the WorkflowRun entity.
func (m *RobotAccountMutation) ClearWorkflowruns() {
	m.clearedworkflowruns = true
}

// WorkflowrunsCleared reports if the "workflowruns" edge to the WorkflowRun entity was cleared.
func (m *RobotAccountMutation) WorkflowrunsCleared() bool {
	return m.clearedworkflowruns
}

// RemoveWorkflowrunIDs removes the "workflowruns" edge to the WorkflowRun entity by IDs.
func (m *RobotAccountMutation) RemoveWorkflowrunIDs(ids ...uuid.UUID) {
	if m.removedworkflowruns == nil {
		m.removedworkflowruns = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.workflowruns, ids[i])
		m.removedworkflowruns[ids[i]] = struct{}{}
	}
}

// RemovedWorkflowruns returns the removed IDs of the "workflowruns" edge to the WorkflowRun entity.
func (m *RobotAccountMutation) RemovedWorkflowrunsIDs() (ids []uuid.UUID) {
	for id := range m.removedworkflowruns {
		ids = append(ids, id)
	}
	return
}

// WorkflowrunsIDs returns the "workflowruns" edge IDs in the mutation.
func (m *RobotAccountMutation) WorkflowrunsIDs() (ids []uuid.UUID) {
	for id := range m.workflowruns {
		ids = append(ids, id)
	}
	return
}

// ResetWorkflowruns resets all changes to the "workflowruns" edge.
func (m *RobotAccountMutation) ResetWorkflowruns() {
	m.workflowruns = nil
	m.clearedworkflowruns = false
	m.removedworkflowruns = nil
}

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

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

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

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

// Type returns the node type of this mutation (RobotAccount).
func (m *RobotAccountMutation) 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 *RobotAccountMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.name != nil {
		fields = append(fields, robotaccount.FieldName)
	}
	if m.created_at != nil {
		fields = append(fields, robotaccount.FieldCreatedAt)
	}
	if m.revoked_at != nil {
		fields = append(fields, robotaccount.FieldRevokedAt)
	}
	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 *RobotAccountMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case robotaccount.FieldName:
		return m.Name()
	case robotaccount.FieldCreatedAt:
		return m.CreatedAt()
	case robotaccount.FieldRevokedAt:
		return m.RevokedAt()
	}
	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 *RobotAccountMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case robotaccount.FieldName:
		return m.OldName(ctx)
	case robotaccount.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case robotaccount.FieldRevokedAt:
		return m.OldRevokedAt(ctx)
	}
	return nil, fmt.Errorf("unknown RobotAccount 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 *RobotAccountMutation) SetField(name string, value ent.Value) error {
	switch name {
	case robotaccount.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case robotaccount.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 robotaccount.FieldRevokedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRevokedAt(v)
		return nil
	}
	return fmt.Errorf("unknown RobotAccount field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *RobotAccountMutation) 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 *RobotAccountMutation) 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 *RobotAccountMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown RobotAccount numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *RobotAccountMutation) 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 *RobotAccountMutation) ClearField(name string) error {
	switch name {
	case robotaccount.FieldRevokedAt:
		m.ClearRevokedAt()
		return nil
	}
	return fmt.Errorf("unknown RobotAccount 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 *RobotAccountMutation) ResetField(name string) error {
	switch name {
	case robotaccount.FieldName:
		m.ResetName()
		return nil
	case robotaccount.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case robotaccount.FieldRevokedAt:
		m.ResetRevokedAt()
		return nil
	}
	return fmt.Errorf("unknown RobotAccount field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *RobotAccountMutation) AddedEdges() []string {
	edges := make([]string, 0, 2)
	if m.workflow != nil {
		edges = append(edges, robotaccount.EdgeWorkflow)
	}
	if m.workflowruns != nil {
		edges = append(edges, robotaccount.EdgeWorkflowruns)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *RobotAccountMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case robotaccount.EdgeWorkflow:
		if id := m.workflow; id != nil {
			return []ent.Value{*id}
		}
	case robotaccount.EdgeWorkflowruns:
		ids := make([]ent.Value, 0, len(m.workflowruns))
		for id := range m.workflowruns {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *RobotAccountMutation) RemovedEdges() []string {
	edges := make([]string, 0, 2)
	if m.removedworkflowruns != nil {
		edges = append(edges, robotaccount.EdgeWorkflowruns)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *RobotAccountMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case robotaccount.EdgeWorkflowruns:
		ids := make([]ent.Value, 0, len(m.removedworkflowruns))
		for id := range m.removedworkflowruns {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *RobotAccountMutation) ClearedEdges() []string {
	edges := make([]string, 0, 2)
	if m.clearedworkflow {
		edges = append(edges, robotaccount.EdgeWorkflow)
	}
	if m.clearedworkflowruns {
		edges = append(edges, robotaccount.EdgeWorkflowruns)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *RobotAccountMutation) EdgeCleared(name string) bool {
	switch name {
	case robotaccount.EdgeWorkflow:
		return m.clearedworkflow
	case robotaccount.EdgeWorkflowruns:
		return m.clearedworkflowruns
	}
	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 *RobotAccountMutation) ClearEdge(name string) error {
	switch name {
	case robotaccount.EdgeWorkflow:
		m.ClearWorkflow()
		return nil
	}
	return fmt.Errorf("unknown RobotAccount 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 *RobotAccountMutation) ResetEdge(name string) error {
	switch name {
	case robotaccount.EdgeWorkflow:
		m.ResetWorkflow()
		return nil
	case robotaccount.EdgeWorkflowruns:
		m.ResetWorkflowruns()
		return nil
	}
	return fmt.Errorf("unknown RobotAccount edge %s", name)
}

// UserMutation represents an operation that mutates the User nodes in the graph.
type UserMutation struct {
	config
	op                 Op
	typ                string
	id                 *uuid.UUID
	email              *string
	created_at         *time.Time
	clearedFields      map[string]struct{}
	memberships        map[uuid.UUID]struct{}
	removedmemberships map[uuid.UUID]struct{}
	clearedmemberships bool
	done               bool
	oldValue           func(context.Context) (*User, error)
	predicates         []predicate.User
}

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

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

// newUserMutation creates new mutation for the User entity.
func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
	m := &UserMutation{
		config:        c,
		op:            op,
		typ:           TypeUser,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withUser sets the old User of the mutation.
func withUser(node *User) userOption {
	return func(m *UserMutation) {
		m.oldValue = func(context.Context) (*User, 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 UserMutation) 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 UserMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of User entities.
func (m *UserMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *UserMutation) ID() (id uuid.UUID, 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 *UserMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().User.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetEmail sets the "email" field.
func (m *UserMutation) SetEmail(s string) {
	m.email = &s
}

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

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

// ResetEmail resets all changes to the "email" field.
func (m *UserMutation) ResetEmail() {
	m.email = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UserMutation) 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 User entity.
// If the User 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 *UserMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *UserMutation) ResetCreatedAt() {
	m.created_at = nil
}

// AddMembershipIDs adds the "memberships" edge to the Membership entity by ids.
func (m *UserMutation) AddMembershipIDs(ids ...uuid.UUID) {
	if m.memberships == nil {
		m.memberships = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.memberships[ids[i]] = struct{}{}
	}
}

// ClearMemberships clears the "memberships" edge to the Membership entity.
func (m *UserMutation) ClearMemberships() {
	m.clearedmemberships = true
}

// MembershipsCleared reports if the "memberships" edge to the Membership entity was cleared.
func (m *UserMutation) MembershipsCleared() bool {
	return m.clearedmemberships
}

// RemoveMembershipIDs removes the "memberships" edge to the Membership entity by IDs.
func (m *UserMutation) RemoveMembershipIDs(ids ...uuid.UUID) {
	if m.removedmemberships == nil {
		m.removedmemberships = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.memberships, ids[i])
		m.removedmemberships[ids[i]] = struct{}{}
	}
}

// RemovedMemberships returns the removed IDs of the "memberships" edge to the Membership entity.
func (m *UserMutation) RemovedMembershipsIDs() (ids []uuid.UUID) {
	for id := range m.removedmemberships {
		ids = append(ids, id)
	}
	return
}

// MembershipsIDs returns the "memberships" edge IDs in the mutation.
func (m *UserMutation) MembershipsIDs() (ids []uuid.UUID) {
	for id := range m.memberships {
		ids = append(ids, id)
	}
	return
}

// ResetMemberships resets all changes to the "memberships" edge.
func (m *UserMutation) ResetMemberships() {
	m.memberships = nil
	m.clearedmemberships = false
	m.removedmemberships = nil
}

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

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

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

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

// Type returns the node type of this mutation (User).
func (m *UserMutation) 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 *UserMutation) Fields() []string {
	fields := make([]string, 0, 2)
	if m.email != nil {
		fields = append(fields, user.FieldEmail)
	}
	if m.created_at != nil {
		fields = append(fields, user.FieldCreatedAt)
	}
	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 *UserMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case user.FieldEmail:
		return m.Email()
	case user.FieldCreatedAt:
		return m.CreatedAt()
	}
	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 *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case user.FieldEmail:
		return m.OldEmail(ctx)
	case user.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown User 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 *UserMutation) SetField(name string, value ent.Value) error {
	switch name {
	case user.FieldEmail:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetEmail(v)
		return nil
	case user.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown User field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UserMutation) 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 *UserMutation) 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 *UserMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown User numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UserMutation) 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 *UserMutation) ClearField(name string) error {
	return fmt.Errorf("unknown User 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 *UserMutation) ResetField(name string) error {
	switch name {
	case user.FieldEmail:
		m.ResetEmail()
		return nil
	case user.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	}
	return fmt.Errorf("unknown User field %s", name)
}

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

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *UserMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case user.EdgeMemberships:
		ids := make([]ent.Value, 0, len(m.memberships))
		for id := range m.memberships {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *UserMutation) RemovedEdges() []string {
	edges := make([]string, 0, 1)
	if m.removedmemberships != nil {
		edges = append(edges, user.EdgeMemberships)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *UserMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case user.EdgeMemberships:
		ids := make([]ent.Value, 0, len(m.removedmemberships))
		for id := range m.removedmemberships {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *UserMutation) EdgeCleared(name string) bool {
	switch name {
	case user.EdgeMemberships:
		return m.clearedmemberships
	}
	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 *UserMutation) ClearEdge(name string) error {
	switch name {
	}
	return fmt.Errorf("unknown User 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 *UserMutation) ResetEdge(name string) error {
	switch name {
	case user.EdgeMemberships:
		m.ResetMemberships()
		return nil
	}
	return fmt.Errorf("unknown User edge %s", name)
}

// WorkflowMutation represents an operation that mutates the Workflow nodes in the graph.
type WorkflowMutation struct {
	config
	op                             Op
	typ                            string
	id                             *uuid.UUID
	name                           *string
	project                        *string
	team                           *string
	runs_count                     *int
	addruns_count                  *int
	created_at                     *time.Time
	deleted_at                     *time.Time
	clearedFields                  map[string]struct{}
	robotaccounts                  map[uuid.UUID]struct{}
	removedrobotaccounts           map[uuid.UUID]struct{}
	clearedrobotaccounts           bool
	workflowruns                   map[uuid.UUID]struct{}
	removedworkflowruns            map[uuid.UUID]struct{}
	clearedworkflowruns            bool
	organization                   *uuid.UUID
	clearedorganization            bool
	contract                       *uuid.UUID
	clearedcontract                bool
	integration_attachments        map[uuid.UUID]struct{}
	removedintegration_attachments map[uuid.UUID]struct{}
	clearedintegration_attachments bool
	done                           bool
	oldValue                       func(context.Context) (*Workflow, error)
	predicates                     []predicate.Workflow
}

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

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

// newWorkflowMutation creates new mutation for the Workflow entity.
func newWorkflowMutation(c config, op Op, opts ...workflowOption) *WorkflowMutation {
	m := &WorkflowMutation{
		config:        c,
		op:            op,
		typ:           TypeWorkflow,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWorkflow sets the old Workflow of the mutation.
func withWorkflow(node *Workflow) workflowOption {
	return func(m *WorkflowMutation) {
		m.oldValue = func(context.Context) (*Workflow, 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 WorkflowMutation) 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 WorkflowMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Workflow entities.
func (m *WorkflowMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *WorkflowMutation) ID() (id uuid.UUID, 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 *WorkflowMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().Workflow.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// Name returns the value of the "name" field in the mutation.
func (m *WorkflowMutation) 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 Workflow entity.
// If the Workflow 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 *WorkflowMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowMutation) ResetName() {
	m.name = nil
}

// SetProject sets the "project" field.
func (m *WorkflowMutation) SetProject(s string) {
	m.project = &s
}

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

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

// ClearProject clears the value of the "project" field.
func (m *WorkflowMutation) ClearProject() {
	m.project = nil
	m.clearedFields[workflow.FieldProject] = struct{}{}
}

// ProjectCleared returns if the "project" field was cleared in this mutation.
func (m *WorkflowMutation) ProjectCleared() bool {
	_, ok := m.clearedFields[workflow.FieldProject]
	return ok
}

// ResetProject resets all changes to the "project" field.
func (m *WorkflowMutation) ResetProject() {
	m.project = nil
	delete(m.clearedFields, workflow.FieldProject)
}

// SetTeam sets the "team" field.
func (m *WorkflowMutation) SetTeam(s string) {
	m.team = &s
}

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

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

// ClearTeam clears the value of the "team" field.
func (m *WorkflowMutation) ClearTeam() {
	m.team = nil
	m.clearedFields[workflow.FieldTeam] = struct{}{}
}

// TeamCleared returns if the "team" field was cleared in this mutation.
func (m *WorkflowMutation) TeamCleared() bool {
	_, ok := m.clearedFields[workflow.FieldTeam]
	return ok
}

// ResetTeam resets all changes to the "team" field.
func (m *WorkflowMutation) ResetTeam() {
	m.team = nil
	delete(m.clearedFields, workflow.FieldTeam)
}

// SetRunsCount sets the "runs_count" field.
func (m *WorkflowMutation) SetRunsCount(i int) {
	m.runs_count = &i
	m.addruns_count = nil
}

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

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

// AddRunsCount adds i to the "runs_count" field.
func (m *WorkflowMutation) AddRunsCount(i int) {
	if m.addruns_count != nil {
		*m.addruns_count += i
	} else {
		m.addruns_count = &i
	}
}

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

// ResetRunsCount resets all changes to the "runs_count" field.
func (m *WorkflowMutation) ResetRunsCount() {
	m.runs_count = nil
	m.addruns_count = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WorkflowMutation) 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 Workflow entity.
// If the Workflow 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 *WorkflowMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetDeletedAt sets the "deleted_at" field.
func (m *WorkflowMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *WorkflowMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[workflow.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *WorkflowMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[workflow.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *WorkflowMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, workflow.FieldDeletedAt)
}

// AddRobotaccountIDs adds the "robotaccounts" edge to the RobotAccount entity by ids.
func (m *WorkflowMutation) AddRobotaccountIDs(ids ...uuid.UUID) {
	if m.robotaccounts == nil {
		m.robotaccounts = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.robotaccounts[ids[i]] = struct{}{}
	}
}

// ClearRobotaccounts clears the "robotaccounts" edge to the RobotAccount entity.
func (m *WorkflowMutation) ClearRobotaccounts() {
	m.clearedrobotaccounts = true
}

// RobotaccountsCleared reports if the "robotaccounts" edge to the RobotAccount entity was cleared.
func (m *WorkflowMutation) RobotaccountsCleared() bool {
	return m.clearedrobotaccounts
}

// RemoveRobotaccountIDs removes the "robotaccounts" edge to the RobotAccount entity by IDs.
func (m *WorkflowMutation) RemoveRobotaccountIDs(ids ...uuid.UUID) {
	if m.removedrobotaccounts == nil {
		m.removedrobotaccounts = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.robotaccounts, ids[i])
		m.removedrobotaccounts[ids[i]] = struct{}{}
	}
}

// RemovedRobotaccounts returns the removed IDs of the "robotaccounts" edge to the RobotAccount entity.
func (m *WorkflowMutation) RemovedRobotaccountsIDs() (ids []uuid.UUID) {
	for id := range m.removedrobotaccounts {
		ids = append(ids, id)
	}
	return
}

// RobotaccountsIDs returns the "robotaccounts" edge IDs in the mutation.
func (m *WorkflowMutation) RobotaccountsIDs() (ids []uuid.UUID) {
	for id := range m.robotaccounts {
		ids = append(ids, id)
	}
	return
}

// ResetRobotaccounts resets all changes to the "robotaccounts" edge.
func (m *WorkflowMutation) ResetRobotaccounts() {
	m.robotaccounts = nil
	m.clearedrobotaccounts = false
	m.removedrobotaccounts = nil
}

// AddWorkflowrunIDs adds the "workflowruns" edge to the WorkflowRun entity by ids.
func (m *WorkflowMutation) AddWorkflowrunIDs(ids ...uuid.UUID) {
	if m.workflowruns == nil {
		m.workflowruns = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.workflowruns[ids[i]] = struct{}{}
	}
}

// ClearWorkflowruns clears the "workflowruns" edge to the WorkflowRun entity.
func (m *WorkflowMutation) ClearWorkflowruns() {
	m.clearedworkflowruns = true
}

// WorkflowrunsCleared reports if the "workflowruns" edge to the WorkflowRun entity was cleared.
func (m *WorkflowMutation) WorkflowrunsCleared() bool {
	return m.clearedworkflowruns
}

// RemoveWorkflowrunIDs removes the "workflowruns" edge to the WorkflowRun entity by IDs.
func (m *WorkflowMutation) RemoveWorkflowrunIDs(ids ...uuid.UUID) {
	if m.removedworkflowruns == nil {
		m.removedworkflowruns = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.workflowruns, ids[i])
		m.removedworkflowruns[ids[i]] = struct{}{}
	}
}

// RemovedWorkflowruns returns the removed IDs of the "workflowruns" edge to the WorkflowRun entity.
func (m *WorkflowMutation) RemovedWorkflowrunsIDs() (ids []uuid.UUID) {
	for id := range m.removedworkflowruns {
		ids = append(ids, id)
	}
	return
}

// WorkflowrunsIDs returns the "workflowruns" edge IDs in the mutation.
func (m *WorkflowMutation) WorkflowrunsIDs() (ids []uuid.UUID) {
	for id := range m.workflowruns {
		ids = append(ids, id)
	}
	return
}

// ResetWorkflowruns resets all changes to the "workflowruns" edge.
func (m *WorkflowMutation) ResetWorkflowruns() {
	m.workflowruns = nil
	m.clearedworkflowruns = false
	m.removedworkflowruns = nil
}

// SetOrganizationID sets the "organization" edge to the Organization entity by id.
func (m *WorkflowMutation) SetOrganizationID(id uuid.UUID) {
	m.organization = &id
}

// ClearOrganization clears the "organization" edge to the Organization entity.
func (m *WorkflowMutation) ClearOrganization() {
	m.clearedorganization = true
}

// OrganizationCleared reports if the "organization" edge to the Organization entity was cleared.
func (m *WorkflowMutation) OrganizationCleared() bool {
	return m.clearedorganization
}

// OrganizationID returns the "organization" edge ID in the mutation.
func (m *WorkflowMutation) OrganizationID() (id uuid.UUID, exists bool) {
	if m.organization != nil {
		return *m.organization, true
	}
	return
}

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

// ResetOrganization resets all changes to the "organization" edge.
func (m *WorkflowMutation) ResetOrganization() {
	m.organization = nil
	m.clearedorganization = false
}

// SetContractID sets the "contract" edge to the WorkflowContract entity by id.
func (m *WorkflowMutation) SetContractID(id uuid.UUID) {
	m.contract = &id
}

// ClearContract clears the "contract" edge to the WorkflowContract entity.
func (m *WorkflowMutation) ClearContract() {
	m.clearedcontract = true
}

// ContractCleared reports if the "contract" edge to the WorkflowContract entity was cleared.
func (m *WorkflowMutation) ContractCleared() bool {
	return m.clearedcontract
}

// ContractID returns the "contract" edge ID in the mutation.
func (m *WorkflowMutation) ContractID() (id uuid.UUID, exists bool) {
	if m.contract != nil {
		return *m.contract, true
	}
	return
}

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

// ResetContract resets all changes to the "contract" edge.
func (m *WorkflowMutation) ResetContract() {
	m.contract = nil
	m.clearedcontract = false
}

// AddIntegrationAttachmentIDs adds the "integration_attachments" edge to the IntegrationAttachment entity by ids.
func (m *WorkflowMutation) AddIntegrationAttachmentIDs(ids ...uuid.UUID) {
	if m.integration_attachments == nil {
		m.integration_attachments = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.integration_attachments[ids[i]] = struct{}{}
	}
}

// ClearIntegrationAttachments clears the "integration_attachments" edge to the IntegrationAttachment entity.
func (m *WorkflowMutation) ClearIntegrationAttachments() {
	m.clearedintegration_attachments = true
}

// IntegrationAttachmentsCleared reports if the "integration_attachments" edge to the IntegrationAttachment entity was cleared.
func (m *WorkflowMutation) IntegrationAttachmentsCleared() bool {
	return m.clearedintegration_attachments
}

// RemoveIntegrationAttachmentIDs removes the "integration_attachments" edge to the IntegrationAttachment entity by IDs.
func (m *WorkflowMutation) RemoveIntegrationAttachmentIDs(ids ...uuid.UUID) {
	if m.removedintegration_attachments == nil {
		m.removedintegration_attachments = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.integration_attachments, ids[i])
		m.removedintegration_attachments[ids[i]] = struct{}{}
	}
}

// RemovedIntegrationAttachments returns the removed IDs of the "integration_attachments" edge to the IntegrationAttachment entity.
func (m *WorkflowMutation) RemovedIntegrationAttachmentsIDs() (ids []uuid.UUID) {
	for id := range m.removedintegration_attachments {
		ids = append(ids, id)
	}
	return
}

// IntegrationAttachmentsIDs returns the "integration_attachments" edge IDs in the mutation.
func (m *WorkflowMutation) IntegrationAttachmentsIDs() (ids []uuid.UUID) {
	for id := range m.integration_attachments {
		ids = append(ids, id)
	}
	return
}

// ResetIntegrationAttachments resets all changes to the "integration_attachments" edge.
func (m *WorkflowMutation) ResetIntegrationAttachments() {
	m.integration_attachments = nil
	m.clearedintegration_attachments = false
	m.removedintegration_attachments = nil
}

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

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

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

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

// Type returns the node type of this mutation (Workflow).
func (m *WorkflowMutation) 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 *WorkflowMutation) Fields() []string {
	fields := make([]string, 0, 6)
	if m.name != nil {
		fields = append(fields, workflow.FieldName)
	}
	if m.project != nil {
		fields = append(fields, workflow.FieldProject)
	}
	if m.team != nil {
		fields = append(fields, workflow.FieldTeam)
	}
	if m.runs_count != nil {
		fields = append(fields, workflow.FieldRunsCount)
	}
	if m.created_at != nil {
		fields = append(fields, workflow.FieldCreatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, workflow.FieldDeletedAt)
	}
	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 *WorkflowMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case workflow.FieldName:
		return m.Name()
	case workflow.FieldProject:
		return m.Project()
	case workflow.FieldTeam:
		return m.Team()
	case workflow.FieldRunsCount:
		return m.RunsCount()
	case workflow.FieldCreatedAt:
		return m.CreatedAt()
	case workflow.FieldDeletedAt:
		return m.DeletedAt()
	}
	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 *WorkflowMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case workflow.FieldName:
		return m.OldName(ctx)
	case workflow.FieldProject:
		return m.OldProject(ctx)
	case workflow.FieldTeam:
		return m.OldTeam(ctx)
	case workflow.FieldRunsCount:
		return m.OldRunsCount(ctx)
	case workflow.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case workflow.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	}
	return nil, fmt.Errorf("unknown Workflow 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 *WorkflowMutation) SetField(name string, value ent.Value) error {
	switch name {
	case workflow.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case workflow.FieldProject:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetProject(v)
		return nil
	case workflow.FieldTeam:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetTeam(v)
		return nil
	case workflow.FieldRunsCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRunsCount(v)
		return nil
	case workflow.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 workflow.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown Workflow field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WorkflowMutation) AddedFields() []string {
	var fields []string
	if m.addruns_count != nil {
		fields = append(fields, workflow.FieldRunsCount)
	}
	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 *WorkflowMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case workflow.FieldRunsCount:
		return m.AddedRunsCount()
	}
	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 *WorkflowMutation) AddField(name string, value ent.Value) error {
	switch name {
	case workflow.FieldRunsCount:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddRunsCount(v)
		return nil
	}
	return fmt.Errorf("unknown Workflow numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WorkflowMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(workflow.FieldProject) {
		fields = append(fields, workflow.FieldProject)
	}
	if m.FieldCleared(workflow.FieldTeam) {
		fields = append(fields, workflow.FieldTeam)
	}
	if m.FieldCleared(workflow.FieldDeletedAt) {
		fields = append(fields, workflow.FieldDeletedAt)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WorkflowMutation) 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 *WorkflowMutation) ClearField(name string) error {
	switch name {
	case workflow.FieldProject:
		m.ClearProject()
		return nil
	case workflow.FieldTeam:
		m.ClearTeam()
		return nil
	case workflow.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Workflow 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 *WorkflowMutation) ResetField(name string) error {
	switch name {
	case workflow.FieldName:
		m.ResetName()
		return nil
	case workflow.FieldProject:
		m.ResetProject()
		return nil
	case workflow.FieldTeam:
		m.ResetTeam()
		return nil
	case workflow.FieldRunsCount:
		m.ResetRunsCount()
		return nil
	case workflow.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case workflow.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown Workflow field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *WorkflowMutation) AddedEdges() []string {
	edges := make([]string, 0, 5)
	if m.robotaccounts != nil {
		edges = append(edges, workflow.EdgeRobotaccounts)
	}
	if m.workflowruns != nil {
		edges = append(edges, workflow.EdgeWorkflowruns)
	}
	if m.organization != nil {
		edges = append(edges, workflow.EdgeOrganization)
	}
	if m.contract != nil {
		edges = append(edges, workflow.EdgeContract)
	}
	if m.integration_attachments != nil {
		edges = append(edges, workflow.EdgeIntegrationAttachments)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WorkflowMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case workflow.EdgeRobotaccounts:
		ids := make([]ent.Value, 0, len(m.robotaccounts))
		for id := range m.robotaccounts {
			ids = append(ids, id)
		}
		return ids
	case workflow.EdgeWorkflowruns:
		ids := make([]ent.Value, 0, len(m.workflowruns))
		for id := range m.workflowruns {
			ids = append(ids, id)
		}
		return ids
	case workflow.EdgeOrganization:
		if id := m.organization; id != nil {
			return []ent.Value{*id}
		}
	case workflow.EdgeContract:
		if id := m.contract; id != nil {
			return []ent.Value{*id}
		}
	case workflow.EdgeIntegrationAttachments:
		ids := make([]ent.Value, 0, len(m.integration_attachments))
		for id := range m.integration_attachments {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *WorkflowMutation) RemovedEdges() []string {
	edges := make([]string, 0, 5)
	if m.removedrobotaccounts != nil {
		edges = append(edges, workflow.EdgeRobotaccounts)
	}
	if m.removedworkflowruns != nil {
		edges = append(edges, workflow.EdgeWorkflowruns)
	}
	if m.removedintegration_attachments != nil {
		edges = append(edges, workflow.EdgeIntegrationAttachments)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *WorkflowMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case workflow.EdgeRobotaccounts:
		ids := make([]ent.Value, 0, len(m.removedrobotaccounts))
		for id := range m.removedrobotaccounts {
			ids = append(ids, id)
		}
		return ids
	case workflow.EdgeWorkflowruns:
		ids := make([]ent.Value, 0, len(m.removedworkflowruns))
		for id := range m.removedworkflowruns {
			ids = append(ids, id)
		}
		return ids
	case workflow.EdgeIntegrationAttachments:
		ids := make([]ent.Value, 0, len(m.removedintegration_attachments))
		for id := range m.removedintegration_attachments {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *WorkflowMutation) ClearedEdges() []string {
	edges := make([]string, 0, 5)
	if m.clearedrobotaccounts {
		edges = append(edges, workflow.EdgeRobotaccounts)
	}
	if m.clearedworkflowruns {
		edges = append(edges, workflow.EdgeWorkflowruns)
	}
	if m.clearedorganization {
		edges = append(edges, workflow.EdgeOrganization)
	}
	if m.clearedcontract {
		edges = append(edges, workflow.EdgeContract)
	}
	if m.clearedintegration_attachments {
		edges = append(edges, workflow.EdgeIntegrationAttachments)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WorkflowMutation) EdgeCleared(name string) bool {
	switch name {
	case workflow.EdgeRobotaccounts:
		return m.clearedrobotaccounts
	case workflow.EdgeWorkflowruns:
		return m.clearedworkflowruns
	case workflow.EdgeOrganization:
		return m.clearedorganization
	case workflow.EdgeContract:
		return m.clearedcontract
	case workflow.EdgeIntegrationAttachments:
		return m.clearedintegration_attachments
	}
	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 *WorkflowMutation) ClearEdge(name string) error {
	switch name {
	case workflow.EdgeOrganization:
		m.ClearOrganization()
		return nil
	case workflow.EdgeContract:
		m.ClearContract()
		return nil
	}
	return fmt.Errorf("unknown Workflow 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 *WorkflowMutation) ResetEdge(name string) error {
	switch name {
	case workflow.EdgeRobotaccounts:
		m.ResetRobotaccounts()
		return nil
	case workflow.EdgeWorkflowruns:
		m.ResetWorkflowruns()
		return nil
	case workflow.EdgeOrganization:
		m.ResetOrganization()
		return nil
	case workflow.EdgeContract:
		m.ResetContract()
		return nil
	case workflow.EdgeIntegrationAttachments:
		m.ResetIntegrationAttachments()
		return nil
	}
	return fmt.Errorf("unknown Workflow edge %s", name)
}

// WorkflowContractMutation represents an operation that mutates the WorkflowContract nodes in the graph.
type WorkflowContractMutation struct {
	config
	op                  Op
	typ                 string
	id                  *uuid.UUID
	name                *string
	created_at          *time.Time
	deleted_at          *time.Time
	clearedFields       map[string]struct{}
	versions            map[uuid.UUID]struct{}
	removedversions     map[uuid.UUID]struct{}
	clearedversions     bool
	organization        *uuid.UUID
	clearedorganization bool
	workflows           map[uuid.UUID]struct{}
	removedworkflows    map[uuid.UUID]struct{}
	clearedworkflows    bool
	done                bool
	oldValue            func(context.Context) (*WorkflowContract, error)
	predicates          []predicate.WorkflowContract
}

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

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

// newWorkflowContractMutation creates new mutation for the WorkflowContract entity.
func newWorkflowContractMutation(c config, op Op, opts ...workflowcontractOption) *WorkflowContractMutation {
	m := &WorkflowContractMutation{
		config:        c,
		op:            op,
		typ:           TypeWorkflowContract,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWorkflowContract sets the old WorkflowContract of the mutation.
func withWorkflowContract(node *WorkflowContract) workflowcontractOption {
	return func(m *WorkflowContractMutation) {
		m.oldValue = func(context.Context) (*WorkflowContract, 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 WorkflowContractMutation) 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 WorkflowContractMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of WorkflowContract entities.
func (m *WorkflowContractMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *WorkflowContractMutation) ID() (id uuid.UUID, 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 *WorkflowContractMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().WorkflowContract.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// Name returns the value of the "name" field in the mutation.
func (m *WorkflowContractMutation) 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 WorkflowContract entity.
// If the WorkflowContract 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 *WorkflowContractMutation) OldName(ctx context.Context) (v string, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldName is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowContractMutation) ResetName() {
	m.name = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WorkflowContractMutation) 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 WorkflowContract entity.
// If the WorkflowContract 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 *WorkflowContractMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowContractMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetDeletedAt sets the "deleted_at" field.
func (m *WorkflowContractMutation) SetDeletedAt(t time.Time) {
	m.deleted_at = &t
}

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

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

// ClearDeletedAt clears the value of the "deleted_at" field.
func (m *WorkflowContractMutation) ClearDeletedAt() {
	m.deleted_at = nil
	m.clearedFields[workflowcontract.FieldDeletedAt] = struct{}{}
}

// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
func (m *WorkflowContractMutation) DeletedAtCleared() bool {
	_, ok := m.clearedFields[workflowcontract.FieldDeletedAt]
	return ok
}

// ResetDeletedAt resets all changes to the "deleted_at" field.
func (m *WorkflowContractMutation) ResetDeletedAt() {
	m.deleted_at = nil
	delete(m.clearedFields, workflowcontract.FieldDeletedAt)
}

// AddVersionIDs adds the "versions" edge to the WorkflowContractVersion entity by ids.
func (m *WorkflowContractMutation) AddVersionIDs(ids ...uuid.UUID) {
	if m.versions == nil {
		m.versions = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.versions[ids[i]] = struct{}{}
	}
}

// ClearVersions clears the "versions" edge to the WorkflowContractVersion entity.
func (m *WorkflowContractMutation) ClearVersions() {
	m.clearedversions = true
}

// VersionsCleared reports if the "versions" edge to the WorkflowContractVersion entity was cleared.
func (m *WorkflowContractMutation) VersionsCleared() bool {
	return m.clearedversions
}

// RemoveVersionIDs removes the "versions" edge to the WorkflowContractVersion entity by IDs.
func (m *WorkflowContractMutation) RemoveVersionIDs(ids ...uuid.UUID) {
	if m.removedversions == nil {
		m.removedversions = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.versions, ids[i])
		m.removedversions[ids[i]] = struct{}{}
	}
}

// RemovedVersions returns the removed IDs of the "versions" edge to the WorkflowContractVersion entity.
func (m *WorkflowContractMutation) RemovedVersionsIDs() (ids []uuid.UUID) {
	for id := range m.removedversions {
		ids = append(ids, id)
	}
	return
}

// VersionsIDs returns the "versions" edge IDs in the mutation.
func (m *WorkflowContractMutation) VersionsIDs() (ids []uuid.UUID) {
	for id := range m.versions {
		ids = append(ids, id)
	}
	return
}

// ResetVersions resets all changes to the "versions" edge.
func (m *WorkflowContractMutation) ResetVersions() {
	m.versions = nil
	m.clearedversions = false
	m.removedversions = nil
}

// SetOrganizationID sets the "organization" edge to the Organization entity by id.
func (m *WorkflowContractMutation) SetOrganizationID(id uuid.UUID) {
	m.organization = &id
}

// ClearOrganization clears the "organization" edge to the Organization entity.
func (m *WorkflowContractMutation) ClearOrganization() {
	m.clearedorganization = true
}

// OrganizationCleared reports if the "organization" edge to the Organization entity was cleared.
func (m *WorkflowContractMutation) OrganizationCleared() bool {
	return m.clearedorganization
}

// OrganizationID returns the "organization" edge ID in the mutation.
func (m *WorkflowContractMutation) OrganizationID() (id uuid.UUID, exists bool) {
	if m.organization != nil {
		return *m.organization, true
	}
	return
}

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

// ResetOrganization resets all changes to the "organization" edge.
func (m *WorkflowContractMutation) ResetOrganization() {
	m.organization = nil
	m.clearedorganization = false
}

// AddWorkflowIDs adds the "workflows" edge to the Workflow entity by ids.
func (m *WorkflowContractMutation) AddWorkflowIDs(ids ...uuid.UUID) {
	if m.workflows == nil {
		m.workflows = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		m.workflows[ids[i]] = struct{}{}
	}
}

// ClearWorkflows clears the "workflows" edge to the Workflow entity.
func (m *WorkflowContractMutation) ClearWorkflows() {
	m.clearedworkflows = true
}

// WorkflowsCleared reports if the "workflows" edge to the Workflow entity was cleared.
func (m *WorkflowContractMutation) WorkflowsCleared() bool {
	return m.clearedworkflows
}

// RemoveWorkflowIDs removes the "workflows" edge to the Workflow entity by IDs.
func (m *WorkflowContractMutation) RemoveWorkflowIDs(ids ...uuid.UUID) {
	if m.removedworkflows == nil {
		m.removedworkflows = make(map[uuid.UUID]struct{})
	}
	for i := range ids {
		delete(m.workflows, ids[i])
		m.removedworkflows[ids[i]] = struct{}{}
	}
}

// RemovedWorkflows returns the removed IDs of the "workflows" edge to the Workflow entity.
func (m *WorkflowContractMutation) RemovedWorkflowsIDs() (ids []uuid.UUID) {
	for id := range m.removedworkflows {
		ids = append(ids, id)
	}
	return
}

// WorkflowsIDs returns the "workflows" edge IDs in the mutation.
func (m *WorkflowContractMutation) WorkflowsIDs() (ids []uuid.UUID) {
	for id := range m.workflows {
		ids = append(ids, id)
	}
	return
}

// ResetWorkflows resets all changes to the "workflows" edge.
func (m *WorkflowContractMutation) ResetWorkflows() {
	m.workflows = nil
	m.clearedworkflows = false
	m.removedworkflows = nil
}

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

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

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

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

// Type returns the node type of this mutation (WorkflowContract).
func (m *WorkflowContractMutation) 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 *WorkflowContractMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.name != nil {
		fields = append(fields, workflowcontract.FieldName)
	}
	if m.created_at != nil {
		fields = append(fields, workflowcontract.FieldCreatedAt)
	}
	if m.deleted_at != nil {
		fields = append(fields, workflowcontract.FieldDeletedAt)
	}
	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 *WorkflowContractMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case workflowcontract.FieldName:
		return m.Name()
	case workflowcontract.FieldCreatedAt:
		return m.CreatedAt()
	case workflowcontract.FieldDeletedAt:
		return m.DeletedAt()
	}
	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 *WorkflowContractMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case workflowcontract.FieldName:
		return m.OldName(ctx)
	case workflowcontract.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case workflowcontract.FieldDeletedAt:
		return m.OldDeletedAt(ctx)
	}
	return nil, fmt.Errorf("unknown WorkflowContract 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 *WorkflowContractMutation) SetField(name string, value ent.Value) error {
	switch name {
	case workflowcontract.FieldName:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetName(v)
		return nil
	case workflowcontract.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 workflowcontract.FieldDeletedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetDeletedAt(v)
		return nil
	}
	return fmt.Errorf("unknown WorkflowContract field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WorkflowContractMutation) 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 *WorkflowContractMutation) 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 *WorkflowContractMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown WorkflowContract numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WorkflowContractMutation) 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 *WorkflowContractMutation) ClearField(name string) error {
	switch name {
	case workflowcontract.FieldDeletedAt:
		m.ClearDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContract 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 *WorkflowContractMutation) ResetField(name string) error {
	switch name {
	case workflowcontract.FieldName:
		m.ResetName()
		return nil
	case workflowcontract.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case workflowcontract.FieldDeletedAt:
		m.ResetDeletedAt()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContract field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *WorkflowContractMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.versions != nil {
		edges = append(edges, workflowcontract.EdgeVersions)
	}
	if m.organization != nil {
		edges = append(edges, workflowcontract.EdgeOrganization)
	}
	if m.workflows != nil {
		edges = append(edges, workflowcontract.EdgeWorkflows)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WorkflowContractMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case workflowcontract.EdgeVersions:
		ids := make([]ent.Value, 0, len(m.versions))
		for id := range m.versions {
			ids = append(ids, id)
		}
		return ids
	case workflowcontract.EdgeOrganization:
		if id := m.organization; id != nil {
			return []ent.Value{*id}
		}
	case workflowcontract.EdgeWorkflows:
		ids := make([]ent.Value, 0, len(m.workflows))
		for id := range m.workflows {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// RemovedEdges returns all edge names that were removed in this mutation.
func (m *WorkflowContractMutation) RemovedEdges() []string {
	edges := make([]string, 0, 3)
	if m.removedversions != nil {
		edges = append(edges, workflowcontract.EdgeVersions)
	}
	if m.removedworkflows != nil {
		edges = append(edges, workflowcontract.EdgeWorkflows)
	}
	return edges
}

// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *WorkflowContractMutation) RemovedIDs(name string) []ent.Value {
	switch name {
	case workflowcontract.EdgeVersions:
		ids := make([]ent.Value, 0, len(m.removedversions))
		for id := range m.removedversions {
			ids = append(ids, id)
		}
		return ids
	case workflowcontract.EdgeWorkflows:
		ids := make([]ent.Value, 0, len(m.removedworkflows))
		for id := range m.removedworkflows {
			ids = append(ids, id)
		}
		return ids
	}
	return nil
}

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *WorkflowContractMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedversions {
		edges = append(edges, workflowcontract.EdgeVersions)
	}
	if m.clearedorganization {
		edges = append(edges, workflowcontract.EdgeOrganization)
	}
	if m.clearedworkflows {
		edges = append(edges, workflowcontract.EdgeWorkflows)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WorkflowContractMutation) EdgeCleared(name string) bool {
	switch name {
	case workflowcontract.EdgeVersions:
		return m.clearedversions
	case workflowcontract.EdgeOrganization:
		return m.clearedorganization
	case workflowcontract.EdgeWorkflows:
		return m.clearedworkflows
	}
	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 *WorkflowContractMutation) ClearEdge(name string) error {
	switch name {
	case workflowcontract.EdgeOrganization:
		m.ClearOrganization()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContract 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 *WorkflowContractMutation) ResetEdge(name string) error {
	switch name {
	case workflowcontract.EdgeVersions:
		m.ResetVersions()
		return nil
	case workflowcontract.EdgeOrganization:
		m.ResetOrganization()
		return nil
	case workflowcontract.EdgeWorkflows:
		m.ResetWorkflows()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContract edge %s", name)
}

// WorkflowContractVersionMutation represents an operation that mutates the WorkflowContractVersion nodes in the graph.
type WorkflowContractVersionMutation struct {
	config
	op              Op
	typ             string
	id              *uuid.UUID
	body            *[]byte
	revision        *int
	addrevision     *int
	created_at      *time.Time
	clearedFields   map[string]struct{}
	contract        *uuid.UUID
	clearedcontract bool
	done            bool
	oldValue        func(context.Context) (*WorkflowContractVersion, error)
	predicates      []predicate.WorkflowContractVersion
}

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

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

// newWorkflowContractVersionMutation creates new mutation for the WorkflowContractVersion entity.
func newWorkflowContractVersionMutation(c config, op Op, opts ...workflowcontractversionOption) *WorkflowContractVersionMutation {
	m := &WorkflowContractVersionMutation{
		config:        c,
		op:            op,
		typ:           TypeWorkflowContractVersion,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWorkflowContractVersion sets the old WorkflowContractVersion of the mutation.
func withWorkflowContractVersion(node *WorkflowContractVersion) workflowcontractversionOption {
	return func(m *WorkflowContractVersionMutation) {
		m.oldValue = func(context.Context) (*WorkflowContractVersion, 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 WorkflowContractVersionMutation) 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 WorkflowContractVersionMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of WorkflowContractVersion entities.
func (m *WorkflowContractVersionMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *WorkflowContractVersionMutation) ID() (id uuid.UUID, 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 *WorkflowContractVersionMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().WorkflowContractVersion.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

// SetBody sets the "body" field.
func (m *WorkflowContractVersionMutation) SetBody(b []byte) {
	m.body = &b
}

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

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

// ResetBody resets all changes to the "body" field.
func (m *WorkflowContractVersionMutation) ResetBody() {
	m.body = nil
}

// SetRevision sets the "revision" field.
func (m *WorkflowContractVersionMutation) SetRevision(i int) {
	m.revision = &i
	m.addrevision = nil
}

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

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

// AddRevision adds i to the "revision" field.
func (m *WorkflowContractVersionMutation) AddRevision(i int) {
	if m.addrevision != nil {
		*m.addrevision += i
	} else {
		m.addrevision = &i
	}
}

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

// ResetRevision resets all changes to the "revision" field.
func (m *WorkflowContractVersionMutation) ResetRevision() {
	m.revision = nil
	m.addrevision = nil
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WorkflowContractVersionMutation) 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 WorkflowContractVersion entity.
// If the WorkflowContractVersion 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 *WorkflowContractVersionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowContractVersionMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetContractID sets the "contract" edge to the WorkflowContract entity by id.
func (m *WorkflowContractVersionMutation) SetContractID(id uuid.UUID) {
	m.contract = &id
}

// ClearContract clears the "contract" edge to the WorkflowContract entity.
func (m *WorkflowContractVersionMutation) ClearContract() {
	m.clearedcontract = true
}

// ContractCleared reports if the "contract" edge to the WorkflowContract entity was cleared.
func (m *WorkflowContractVersionMutation) ContractCleared() bool {
	return m.clearedcontract
}

// ContractID returns the "contract" edge ID in the mutation.
func (m *WorkflowContractVersionMutation) ContractID() (id uuid.UUID, exists bool) {
	if m.contract != nil {
		return *m.contract, true
	}
	return
}

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

// ResetContract resets all changes to the "contract" edge.
func (m *WorkflowContractVersionMutation) ResetContract() {
	m.contract = nil
	m.clearedcontract = false
}

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

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

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

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

// Type returns the node type of this mutation (WorkflowContractVersion).
func (m *WorkflowContractVersionMutation) 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 *WorkflowContractVersionMutation) Fields() []string {
	fields := make([]string, 0, 3)
	if m.body != nil {
		fields = append(fields, workflowcontractversion.FieldBody)
	}
	if m.revision != nil {
		fields = append(fields, workflowcontractversion.FieldRevision)
	}
	if m.created_at != nil {
		fields = append(fields, workflowcontractversion.FieldCreatedAt)
	}
	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 *WorkflowContractVersionMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case workflowcontractversion.FieldBody:
		return m.Body()
	case workflowcontractversion.FieldRevision:
		return m.Revision()
	case workflowcontractversion.FieldCreatedAt:
		return m.CreatedAt()
	}
	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 *WorkflowContractVersionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case workflowcontractversion.FieldBody:
		return m.OldBody(ctx)
	case workflowcontractversion.FieldRevision:
		return m.OldRevision(ctx)
	case workflowcontractversion.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	}
	return nil, fmt.Errorf("unknown WorkflowContractVersion 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 *WorkflowContractVersionMutation) SetField(name string, value ent.Value) error {
	switch name {
	case workflowcontractversion.FieldBody:
		v, ok := value.([]byte)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetBody(v)
		return nil
	case workflowcontractversion.FieldRevision:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRevision(v)
		return nil
	case workflowcontractversion.FieldCreatedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetCreatedAt(v)
		return nil
	}
	return fmt.Errorf("unknown WorkflowContractVersion field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WorkflowContractVersionMutation) AddedFields() []string {
	var fields []string
	if m.addrevision != nil {
		fields = append(fields, workflowcontractversion.FieldRevision)
	}
	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 *WorkflowContractVersionMutation) AddedField(name string) (ent.Value, bool) {
	switch name {
	case workflowcontractversion.FieldRevision:
		return m.AddedRevision()
	}
	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 *WorkflowContractVersionMutation) AddField(name string, value ent.Value) error {
	switch name {
	case workflowcontractversion.FieldRevision:
		v, ok := value.(int)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.AddRevision(v)
		return nil
	}
	return fmt.Errorf("unknown WorkflowContractVersion numeric field %s", name)
}

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

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WorkflowContractVersionMutation) 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 *WorkflowContractVersionMutation) ClearField(name string) error {
	return fmt.Errorf("unknown WorkflowContractVersion 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 *WorkflowContractVersionMutation) ResetField(name string) error {
	switch name {
	case workflowcontractversion.FieldBody:
		m.ResetBody()
		return nil
	case workflowcontractversion.FieldRevision:
		m.ResetRevision()
		return nil
	case workflowcontractversion.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContractVersion field %s", name)
}

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

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

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

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

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WorkflowContractVersionMutation) EdgeCleared(name string) bool {
	switch name {
	case workflowcontractversion.EdgeContract:
		return m.clearedcontract
	}
	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 *WorkflowContractVersionMutation) ClearEdge(name string) error {
	switch name {
	case workflowcontractversion.EdgeContract:
		m.ClearContract()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContractVersion 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 *WorkflowContractVersionMutation) ResetEdge(name string) error {
	switch name {
	case workflowcontractversion.EdgeContract:
		m.ResetContract()
		return nil
	}
	return fmt.Errorf("unknown WorkflowContractVersion edge %s", name)
}

// WorkflowRunMutation represents an operation that mutates the WorkflowRun nodes in the graph.
type WorkflowRunMutation struct {
	config
	op                      Op
	typ                     string
	id                      *uuid.UUID
	created_at              *time.Time
	finished_at             *time.Time
	state                   *biz.WorkflowRunStatus
	reason                  *string
	run_url                 *string
	runner_type             *string
	attestation_ref         **biz.AttestationRef
	clearedFields           map[string]struct{}
	workflow                *uuid.UUID
	clearedworkflow         bool
	robotaccount            *uuid.UUID
	clearedrobotaccount     bool
	contract_version        *uuid.UUID
	clearedcontract_version bool
	done                    bool
	oldValue                func(context.Context) (*WorkflowRun, error)
	predicates              []predicate.WorkflowRun
}

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

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

// newWorkflowRunMutation creates new mutation for the WorkflowRun entity.
func newWorkflowRunMutation(c config, op Op, opts ...workflowrunOption) *WorkflowRunMutation {
	m := &WorkflowRunMutation{
		config:        c,
		op:            op,
		typ:           TypeWorkflowRun,
		clearedFields: make(map[string]struct{}),
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

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

// withWorkflowRun sets the old WorkflowRun of the mutation.
func withWorkflowRun(node *WorkflowRun) workflowrunOption {
	return func(m *WorkflowRunMutation) {
		m.oldValue = func(context.Context) (*WorkflowRun, 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 WorkflowRunMutation) 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 WorkflowRunMutation) Tx() (*Tx, error) {
	if _, ok := m.driver.(*txDriver); !ok {
		return nil, errors.New("ent: mutation is not running in a transaction")
	}
	tx := &Tx{config: m.config}
	tx.init()
	return tx, nil
}

// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of WorkflowRun entities.
func (m *WorkflowRunMutation) SetID(id uuid.UUID) {
	m.id = &id
}

// 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 *WorkflowRunMutation) ID() (id uuid.UUID, 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 *WorkflowRunMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
	switch {
	case m.op.Is(OpUpdateOne | OpDeleteOne):
		id, exists := m.ID()
		if exists {
			return []uuid.UUID{id}, nil
		}
		fallthrough
	case m.op.Is(OpUpdate | OpDelete):
		return m.Client().WorkflowRun.Query().Where(m.predicates...).IDs(ctx)
	default:
		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
	}
}

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

// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *WorkflowRunMutation) 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 WorkflowRun entity.
// If the WorkflowRun 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 *WorkflowRunMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
	if !m.op.Is(OpUpdateOne) {
		return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
	}
	if m.id == nil || m.oldValue == nil {
		return v, errors.New("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 *WorkflowRunMutation) ResetCreatedAt() {
	m.created_at = nil
}

// SetFinishedAt sets the "finished_at" field.
func (m *WorkflowRunMutation) SetFinishedAt(t time.Time) {
	m.finished_at = &t
}

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

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

// ClearFinishedAt clears the value of the "finished_at" field.
func (m *WorkflowRunMutation) ClearFinishedAt() {
	m.finished_at = nil
	m.clearedFields[workflowrun.FieldFinishedAt] = struct{}{}
}

// FinishedAtCleared returns if the "finished_at" field was cleared in this mutation.
func (m *WorkflowRunMutation) FinishedAtCleared() bool {
	_, ok := m.clearedFields[workflowrun.FieldFinishedAt]
	return ok
}

// ResetFinishedAt resets all changes to the "finished_at" field.
func (m *WorkflowRunMutation) ResetFinishedAt() {
	m.finished_at = nil
	delete(m.clearedFields, workflowrun.FieldFinishedAt)
}

// SetState sets the "state" field.
func (m *WorkflowRunMutation) SetState(brs biz.WorkflowRunStatus) {
	m.state = &brs
}

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

// OldState returns the old "state" field's value of the WorkflowRun entity.
// If the WorkflowRun 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 *WorkflowRunMutation) OldState(ctx context.Context) (v biz.WorkflowRunStatus, 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 *WorkflowRunMutation) ResetState() {
	m.state = nil
}

// SetReason sets the "reason" field.
func (m *WorkflowRunMutation) SetReason(s string) {
	m.reason = &s
}

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

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

// ClearReason clears the value of the "reason" field.
func (m *WorkflowRunMutation) ClearReason() {
	m.reason = nil
	m.clearedFields[workflowrun.FieldReason] = struct{}{}
}

// ReasonCleared returns if the "reason" field was cleared in this mutation.
func (m *WorkflowRunMutation) ReasonCleared() bool {
	_, ok := m.clearedFields[workflowrun.FieldReason]
	return ok
}

// ResetReason resets all changes to the "reason" field.
func (m *WorkflowRunMutation) ResetReason() {
	m.reason = nil
	delete(m.clearedFields, workflowrun.FieldReason)
}

// SetRunURL sets the "run_url" field.
func (m *WorkflowRunMutation) SetRunURL(s string) {
	m.run_url = &s
}

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

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

// ClearRunURL clears the value of the "run_url" field.
func (m *WorkflowRunMutation) ClearRunURL() {
	m.run_url = nil
	m.clearedFields[workflowrun.FieldRunURL] = struct{}{}
}

// RunURLCleared returns if the "run_url" field was cleared in this mutation.
func (m *WorkflowRunMutation) RunURLCleared() bool {
	_, ok := m.clearedFields[workflowrun.FieldRunURL]
	return ok
}

// ResetRunURL resets all changes to the "run_url" field.
func (m *WorkflowRunMutation) ResetRunURL() {
	m.run_url = nil
	delete(m.clearedFields, workflowrun.FieldRunURL)
}

// SetRunnerType sets the "runner_type" field.
func (m *WorkflowRunMutation) SetRunnerType(s string) {
	m.runner_type = &s
}

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

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

// ClearRunnerType clears the value of the "runner_type" field.
func (m *WorkflowRunMutation) ClearRunnerType() {
	m.runner_type = nil
	m.clearedFields[workflowrun.FieldRunnerType] = struct{}{}
}

// RunnerTypeCleared returns if the "runner_type" field was cleared in this mutation.
func (m *WorkflowRunMutation) RunnerTypeCleared() bool {
	_, ok := m.clearedFields[workflowrun.FieldRunnerType]
	return ok
}

// ResetRunnerType resets all changes to the "runner_type" field.
func (m *WorkflowRunMutation) ResetRunnerType() {
	m.runner_type = nil
	delete(m.clearedFields, workflowrun.FieldRunnerType)
}

// SetAttestationRef sets the "attestation_ref" field.
func (m *WorkflowRunMutation) SetAttestationRef(br *biz.AttestationRef) {
	m.attestation_ref = &br
}

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

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

// ClearAttestationRef clears the value of the "attestation_ref" field.
func (m *WorkflowRunMutation) ClearAttestationRef() {
	m.attestation_ref = nil
	m.clearedFields[workflowrun.FieldAttestationRef] = struct{}{}
}

// AttestationRefCleared returns if the "attestation_ref" field was cleared in this mutation.
func (m *WorkflowRunMutation) AttestationRefCleared() bool {
	_, ok := m.clearedFields[workflowrun.FieldAttestationRef]
	return ok
}

// ResetAttestationRef resets all changes to the "attestation_ref" field.
func (m *WorkflowRunMutation) ResetAttestationRef() {
	m.attestation_ref = nil
	delete(m.clearedFields, workflowrun.FieldAttestationRef)
}

// SetWorkflowID sets the "workflow" edge to the Workflow entity by id.
func (m *WorkflowRunMutation) SetWorkflowID(id uuid.UUID) {
	m.workflow = &id
}

// ClearWorkflow clears the "workflow" edge to the Workflow entity.
func (m *WorkflowRunMutation) ClearWorkflow() {
	m.clearedworkflow = true
}

// WorkflowCleared reports if the "workflow" edge to the Workflow entity was cleared.
func (m *WorkflowRunMutation) WorkflowCleared() bool {
	return m.clearedworkflow
}

// WorkflowID returns the "workflow" edge ID in the mutation.
func (m *WorkflowRunMutation) WorkflowID() (id uuid.UUID, exists bool) {
	if m.workflow != nil {
		return *m.workflow, true
	}
	return
}

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

// ResetWorkflow resets all changes to the "workflow" edge.
func (m *WorkflowRunMutation) ResetWorkflow() {
	m.workflow = nil
	m.clearedworkflow = false
}

// SetRobotaccountID sets the "robotaccount" edge to the RobotAccount entity by id.
func (m *WorkflowRunMutation) SetRobotaccountID(id uuid.UUID) {
	m.robotaccount = &id
}

// ClearRobotaccount clears the "robotaccount" edge to the RobotAccount entity.
func (m *WorkflowRunMutation) ClearRobotaccount() {
	m.clearedrobotaccount = true
}

// RobotaccountCleared reports if the "robotaccount" edge to the RobotAccount entity was cleared.
func (m *WorkflowRunMutation) RobotaccountCleared() bool {
	return m.clearedrobotaccount
}

// RobotaccountID returns the "robotaccount" edge ID in the mutation.
func (m *WorkflowRunMutation) RobotaccountID() (id uuid.UUID, exists bool) {
	if m.robotaccount != nil {
		return *m.robotaccount, true
	}
	return
}

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

// ResetRobotaccount resets all changes to the "robotaccount" edge.
func (m *WorkflowRunMutation) ResetRobotaccount() {
	m.robotaccount = nil
	m.clearedrobotaccount = false
}

// SetContractVersionID sets the "contract_version" edge to the WorkflowContractVersion entity by id.
func (m *WorkflowRunMutation) SetContractVersionID(id uuid.UUID) {
	m.contract_version = &id
}

// ClearContractVersion clears the "contract_version" edge to the WorkflowContractVersion entity.
func (m *WorkflowRunMutation) ClearContractVersion() {
	m.clearedcontract_version = true
}

// ContractVersionCleared reports if the "contract_version" edge to the WorkflowContractVersion entity was cleared.
func (m *WorkflowRunMutation) ContractVersionCleared() bool {
	return m.clearedcontract_version
}

// ContractVersionID returns the "contract_version" edge ID in the mutation.
func (m *WorkflowRunMutation) ContractVersionID() (id uuid.UUID, exists bool) {
	if m.contract_version != nil {
		return *m.contract_version, true
	}
	return
}

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

// ResetContractVersion resets all changes to the "contract_version" edge.
func (m *WorkflowRunMutation) ResetContractVersion() {
	m.contract_version = nil
	m.clearedcontract_version = false
}

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

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

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

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

// Type returns the node type of this mutation (WorkflowRun).
func (m *WorkflowRunMutation) 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 *WorkflowRunMutation) Fields() []string {
	fields := make([]string, 0, 7)
	if m.created_at != nil {
		fields = append(fields, workflowrun.FieldCreatedAt)
	}
	if m.finished_at != nil {
		fields = append(fields, workflowrun.FieldFinishedAt)
	}
	if m.state != nil {
		fields = append(fields, workflowrun.FieldState)
	}
	if m.reason != nil {
		fields = append(fields, workflowrun.FieldReason)
	}
	if m.run_url != nil {
		fields = append(fields, workflowrun.FieldRunURL)
	}
	if m.runner_type != nil {
		fields = append(fields, workflowrun.FieldRunnerType)
	}
	if m.attestation_ref != nil {
		fields = append(fields, workflowrun.FieldAttestationRef)
	}
	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 *WorkflowRunMutation) Field(name string) (ent.Value, bool) {
	switch name {
	case workflowrun.FieldCreatedAt:
		return m.CreatedAt()
	case workflowrun.FieldFinishedAt:
		return m.FinishedAt()
	case workflowrun.FieldState:
		return m.State()
	case workflowrun.FieldReason:
		return m.Reason()
	case workflowrun.FieldRunURL:
		return m.RunURL()
	case workflowrun.FieldRunnerType:
		return m.RunnerType()
	case workflowrun.FieldAttestationRef:
		return m.AttestationRef()
	}
	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 *WorkflowRunMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
	switch name {
	case workflowrun.FieldCreatedAt:
		return m.OldCreatedAt(ctx)
	case workflowrun.FieldFinishedAt:
		return m.OldFinishedAt(ctx)
	case workflowrun.FieldState:
		return m.OldState(ctx)
	case workflowrun.FieldReason:
		return m.OldReason(ctx)
	case workflowrun.FieldRunURL:
		return m.OldRunURL(ctx)
	case workflowrun.FieldRunnerType:
		return m.OldRunnerType(ctx)
	case workflowrun.FieldAttestationRef:
		return m.OldAttestationRef(ctx)
	}
	return nil, fmt.Errorf("unknown WorkflowRun 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 *WorkflowRunMutation) SetField(name string, value ent.Value) error {
	switch name {
	case workflowrun.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 workflowrun.FieldFinishedAt:
		v, ok := value.(time.Time)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetFinishedAt(v)
		return nil
	case workflowrun.FieldState:
		v, ok := value.(biz.WorkflowRunStatus)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetState(v)
		return nil
	case workflowrun.FieldReason:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetReason(v)
		return nil
	case workflowrun.FieldRunURL:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRunURL(v)
		return nil
	case workflowrun.FieldRunnerType:
		v, ok := value.(string)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetRunnerType(v)
		return nil
	case workflowrun.FieldAttestationRef:
		v, ok := value.(*biz.AttestationRef)
		if !ok {
			return fmt.Errorf("unexpected type %T for field %s", value, name)
		}
		m.SetAttestationRef(v)
		return nil
	}
	return fmt.Errorf("unknown WorkflowRun field %s", name)
}

// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *WorkflowRunMutation) 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 *WorkflowRunMutation) 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 *WorkflowRunMutation) AddField(name string, value ent.Value) error {
	switch name {
	}
	return fmt.Errorf("unknown WorkflowRun numeric field %s", name)
}

// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *WorkflowRunMutation) ClearedFields() []string {
	var fields []string
	if m.FieldCleared(workflowrun.FieldFinishedAt) {
		fields = append(fields, workflowrun.FieldFinishedAt)
	}
	if m.FieldCleared(workflowrun.FieldReason) {
		fields = append(fields, workflowrun.FieldReason)
	}
	if m.FieldCleared(workflowrun.FieldRunURL) {
		fields = append(fields, workflowrun.FieldRunURL)
	}
	if m.FieldCleared(workflowrun.FieldRunnerType) {
		fields = append(fields, workflowrun.FieldRunnerType)
	}
	if m.FieldCleared(workflowrun.FieldAttestationRef) {
		fields = append(fields, workflowrun.FieldAttestationRef)
	}
	return fields
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *WorkflowRunMutation) 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 *WorkflowRunMutation) ClearField(name string) error {
	switch name {
	case workflowrun.FieldFinishedAt:
		m.ClearFinishedAt()
		return nil
	case workflowrun.FieldReason:
		m.ClearReason()
		return nil
	case workflowrun.FieldRunURL:
		m.ClearRunURL()
		return nil
	case workflowrun.FieldRunnerType:
		m.ClearRunnerType()
		return nil
	case workflowrun.FieldAttestationRef:
		m.ClearAttestationRef()
		return nil
	}
	return fmt.Errorf("unknown WorkflowRun 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 *WorkflowRunMutation) ResetField(name string) error {
	switch name {
	case workflowrun.FieldCreatedAt:
		m.ResetCreatedAt()
		return nil
	case workflowrun.FieldFinishedAt:
		m.ResetFinishedAt()
		return nil
	case workflowrun.FieldState:
		m.ResetState()
		return nil
	case workflowrun.FieldReason:
		m.ResetReason()
		return nil
	case workflowrun.FieldRunURL:
		m.ResetRunURL()
		return nil
	case workflowrun.FieldRunnerType:
		m.ResetRunnerType()
		return nil
	case workflowrun.FieldAttestationRef:
		m.ResetAttestationRef()
		return nil
	}
	return fmt.Errorf("unknown WorkflowRun field %s", name)
}

// AddedEdges returns all edge names that were set/added in this mutation.
func (m *WorkflowRunMutation) AddedEdges() []string {
	edges := make([]string, 0, 3)
	if m.workflow != nil {
		edges = append(edges, workflowrun.EdgeWorkflow)
	}
	if m.robotaccount != nil {
		edges = append(edges, workflowrun.EdgeRobotaccount)
	}
	if m.contract_version != nil {
		edges = append(edges, workflowrun.EdgeContractVersion)
	}
	return edges
}

// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *WorkflowRunMutation) AddedIDs(name string) []ent.Value {
	switch name {
	case workflowrun.EdgeWorkflow:
		if id := m.workflow; id != nil {
			return []ent.Value{*id}
		}
	case workflowrun.EdgeRobotaccount:
		if id := m.robotaccount; id != nil {
			return []ent.Value{*id}
		}
	case workflowrun.EdgeContractVersion:
		if id := m.contract_version; id != nil {
			return []ent.Value{*id}
		}
	}
	return nil
}

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

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

// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *WorkflowRunMutation) ClearedEdges() []string {
	edges := make([]string, 0, 3)
	if m.clearedworkflow {
		edges = append(edges, workflowrun.EdgeWorkflow)
	}
	if m.clearedrobotaccount {
		edges = append(edges, workflowrun.EdgeRobotaccount)
	}
	if m.clearedcontract_version {
		edges = append(edges, workflowrun.EdgeContractVersion)
	}
	return edges
}

// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *WorkflowRunMutation) EdgeCleared(name string) bool {
	switch name {
	case workflowrun.EdgeWorkflow:
		return m.clearedworkflow
	case workflowrun.EdgeRobotaccount:
		return m.clearedrobotaccount
	case workflowrun.EdgeContractVersion:
		return m.clearedcontract_version
	}
	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 *WorkflowRunMutation) ClearEdge(name string) error {
	switch name {
	case workflowrun.EdgeWorkflow:
		m.ClearWorkflow()
		return nil
	case workflowrun.EdgeRobotaccount:
		m.ClearRobotaccount()
		return nil
	case workflowrun.EdgeContractVersion:
		m.ClearContractVersion()
		return nil
	}
	return fmt.Errorf("unknown WorkflowRun 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 *WorkflowRunMutation) ResetEdge(name string) error {
	switch name {
	case workflowrun.EdgeWorkflow:
		m.ResetWorkflow()
		return nil
	case workflowrun.EdgeRobotaccount:
		m.ResetRobotaccount()
		return nil
	case workflowrun.EdgeContractVersion:
		m.ResetContractVersion()
		return nil
	}
	return fmt.Errorf("unknown WorkflowRun edge %s", name)
}