relations

type Builder interface {
	contractsorm.Query

	// GroupLimit sets the query builder's "group limit" — Query\Builder::groupLimit
	// (Builder.php:3128), reached from the relation objects' limit() through
	// Eloquent\Builder::__call when the parent does not exist: the select compiles as the
	// row_number() over (partition by column) derived table bounded at value rows per group.
	GroupLimit(value int, column string) contractsorm.Query
	// UseLegacyGroupLimit reports whether the bound grammar compiles the group limit through
	// the legacy rewrite (MySqlGrammar::useLegacyGroupLimit — MySQL before 8.0.11), the
	// decision HasOneOrManyThrough::limit (:779-783) and BelongsToMany::limit (:1510-1514)
	// consult before choosing the partition column.
	UseLegacyGroupLimit() bool

	SaveRelation(parent any, relation string, child any) error
	SaveManyRelation(parent any, relation string, children any) error
	SaveRelationWithPivot(parent any, relation string, child any, attrs map[string]any) error
	SaveManyRelationWithPivot(parent any, relation string, children any, attrsPerChild map[any]map[string]any) error
	AssociateRelation(parent any, relation string, owner any) error
	DissociateRelation(parent any, relation string) error
	CreateRelation(parent any, relation string, dest any) error
	CreateManyRelation(parent any, relation string, dests any) error
	FindOrNewRelation(parent any, relation string, id any, dest any) error
	FirstOrNewRelation(parent any, relation string, attrs map[string]any, values map[string]any, dest any) error
	FirstOrCreateRelation(parent any, relation string, attrs map[string]any, values map[string]any, dest any) error
	UpdateOrCreateRelation(parent any, relation string, attrs map[string]any, values map[string]any, dest any) error
	CreateOrFirstRelation(parent any, relation string, attrs map[string]any, values map[string]any, dest any) error
	MakeRelation(parent any, relation string, attrs map[string]any, dest any) error
	MakeManyRelation(parent any, relation string, records []map[string]any, dests any) error
	UpsertRelation(parent any, relation string, values []map[string]any, uniqueBy []string, update ...any) (*dbcontract.Result, error)
	AttachRelation(parent any, relation string, ids []any) error
	AttachWithPivotRelation(parent any, relation string, idsWithAttrs map[any]map[string]any) error
	DetachRelation(parent any, relation string, ids []any) (int64, error)
	SyncRelation(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	SyncRelationWithPivot(parent any, relation string, idsWithAttrs map[any]map[string]any) (*dbcontract.SyncResult, error)
	SyncRelationWithPivotValues(parent any, relation string, ids []any, pivotValues map[string]any) (*dbcontract.SyncResult, error)
	SyncWithoutDetachingRelation(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	SyncWithoutDetachingRelationWithPivot(parent any, relation string, idsWithAttrs map[any]map[string]any) (*dbcontract.SyncResult, error)
	ToggleRelation(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	ToggleRelationWithPivot(parent any, relation string, idsWithAttrs map[any]map[string]any) (*dbcontract.SyncResult, error)
	UpdateExistingPivotRelation(parent any, relation string, id any, attrs map[string]any) (int64, error)

	// Quiet and OrFail write families: the shells the relation objects' quiet / forceCreate /
	// OrFail methods forward to — Laravel's HasOneOrMany quiet family
	// (HasOneOrMany.php:345/373/403/455; forceCreateQuietly :427) and InteractsWithPivotTable's
	// OrFail family (InteractsWithPivotTable.php:75/157/170/200/299/365/562). The quiet shells
	// run the same write with the without-events flag set on the fresh persistence session; the
	// OrFail shells wrap the base shell in a transaction on this builder's connection.
	SaveRelationQuietly(parent any, relation string, child any) error
	SaveManyRelationQuietly(parent any, relation string, children any) error
	CreateRelationQuietly(parent any, relation string, dest any) error
	CreateManyRelationQuietly(parent any, relation string, dests any) error
	AttachRelationOrFail(parent any, relation string, ids []any) error
	DetachRelationOrFail(parent any, relation string, ids []any) (int64, error)
	SyncRelationOrFail(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	SyncWithoutDetachingRelationOrFail(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	SyncRelationWithPivotValuesOrFail(parent any, relation string, ids []any, pivotValues map[string]any) (*dbcontract.SyncResult, error)
	ToggleRelationOrFail(parent any, relation string, ids []any) (*dbcontract.SyncResult, error)
	UpdateExistingPivotRelationOrFail(parent any, relation string, id any, attrs map[string]any) (int64, error)

	// Pivot execution surface — the frozen widening relations.Pivot runs on (the complete design
	// note, justified call by call against AsPivot, lives in relations/pivot.go):
	//
	// NewPivotQuery builds a fresh builder bound to the pivot's own table on the pivot's
	// connection ("" keeps the current one) — the handle every select / update / delete / insert
	// the pivot runs goes through. ReadPivotParent reads the parent model's pivot metadata (the
	// declared connection name and the created-at / updated-at column names). PivotTouchOwners is
	// AsPivot's touchOwners() call. FirePivotEvent dispatches one model event on the pivot when a
	// handler is registered for the pivot's type.
	NewPivotQuery(table string, connection string) (contractsorm.Query, error)
	ReadPivotParent(parent any) (PivotParentInfo, error)
	PivotTouchOwners(pivot any) error
	FirePivotEvent(name string, pivot any) error

	// ColumnValue reads the value of a DB column off a model — W2, the promoted Hooks.ReadColumn:
	// the schema-resolved read readParentColumn performs, with its "no parent field" error for a
	// column the model's schema lacks.
	ColumnValue(model any, column string) (any, error)
	// SetColumn writes value into the model's column through the parsed schema — W1, the
	// schemaField.Set call mutateAssociate / mutateDissociate / setRelationFKOnChild / applyAttrMap
	// / touchIfTouching make. model must be a non-nil pointer to a struct. The bool reports
	// whether the schema carries the column: false (with no error) lets a caller keep the
	// workers' own absent-column handling — applyAttrMap skips, the FK writers raise
	// OrmRelationUnsupported with their relation-specific message.
	SetColumn(model any, column string, value any) (bool, error)
	// ColumnType reports the Go type of the model's column — W3, the schemaField.FieldType the
	// dissociate writers zero and castKeys targets. false when the schema carries no such column.
	ColumnType(model any, column string) (reflect.Type, bool, error)
	// TableOf resolves a model's declared table name without the connection prefix — tableNameFor,
	// the error-reporting form of Hooks.ModelTable.
	TableOf(model any) (string, error)
	// RelationInfoOf resolves parent's relation by name and hands back its projection — the
	// resolveRelation call every write shell opens with, projected through the same bridge Wrap
	// receives (relationInfoFromDescriptor), including the W9 fields.
	RelationInfoOf(parent any, relation string) (RelationInfo, error)
	// NewQuery builds the same query with no state of its own — fresh(), the session
	// applyAssociate / applyDissociate / createOrFirstRelation persist through.
	NewQuery() contractsorm.Query
	// WriteSession is the fresh session a relation write persists through, keeping the caller's
	// event suppression — relationWriteSession(), what the Save / Create shells spawn.
	WriteSession() contractsorm.Query
	// WithSavepoint runs scope directly outside a transaction and inside a savepoint within one —
	// W8, withSavepointIfNeeded, Eloquent's Builder::withSavepointIfNeeded.
	WithSavepoint(scope func() error) error
	// FirstFound runs this query as a single-row read into dest and reports whether a row was
	// found — firstRow, the flag Query.First discards and the find-then-write family branches on.
	FirstFound(dest any) (bool, error)
	// Ident renders a dotted identifier with the connection's own quoting — ident, the column
	// side of every equality fragment the pivot workers hand pivotWhere.
	Ident(parts ...string) string
	// InsertRows inserts rows into table through the compiled insert — W4, insertPivotRows: the
	// rows are given the union of their columns first (uniformInsertRecords) and the statement
	// runs on the connection pool. No pivot scope is replayed — Laravel's attach writes the
	// pivot row without the wherePivot constraints as well.
	InsertRows(table string, rows []map[string]any) error
	// UpdateRows compiles and runs an update of values on table — W5, the
	// doUpdateExistingPivot / touchIfTouching statement: a fresh builder bound to table, each
	// RowWhere appended in order through addWhere, the pivot scope replayed last (nil skips it),
	// then compileUpdate + execStatement. Reports the rows affected.
	UpdateRows(table string, wheres []RowWhere, scope contractsorm.PivotCallback, values map[string]any) (int64, error)
	// DeleteRows compiles and runs a delete on table — W6, the doDetach statement, assembled the
	// way UpdateRows assembles its update and run through execDelete. Reports the rows affected.
	DeleteRows(table string, wheres []RowWhere, scope contractsorm.PivotCallback) (int64, error)
	// SelectRows reads the given columns of table into column-keyed maps — W7, the
	// existingPivotIDs / allPivotIDs read: the select list set on the fresh builder, each RowWhere
	// appended in order, the pivot scope replayed and the statement read through findMapsCompiled.
	SelectRows(table string, columns []string, wheres []RowWhere, scope contractsorm.PivotCallback) ([]map[string]any, error)
	// IsIgnoringTouch reports whether a model's class ignores touches — database/orm's
	// IsIgnoringTouch, Eloquent's Model::isIgnoringTouch, read per call because a WithoutTouching
	// scope toggles the ignore list only for the span of its callback.
	IsIgnoringTouch(model any) bool
	// MorphAliasOf reports the morph alias a model registers through MorphClass() or the morph
	// map, without the table-name fallback — resolveMorphAlias, the Associate owner-type read.
	// ok is false for an unmapped model; strict morph mode reports the violation through err.
	MorphAliasOf(model any) (string, bool, error)
	// IsUniqueConstraintViolation reports whether err is a unique-constraint violation the way
	// each supported connection classifies one — isUniqueConstraintViolation, Eloquent's
	// Connection::isUniqueConstraintError, the createOrFirst catch.
	IsUniqueConstraintViolation(err error) bool
	// InverseWriteBackName reports the inverse relation name a relation write links the child
	// back to — inverseWriteBackName: the live chaperone state when this builder carries one (a
	// relation object installed it at wrap time and WithoutChaperone / WithoutInverse cleared it
	// to ""), the declared name otherwise. "" means no write-back.
	InverseWriteBackName(declared string) string
	// SetRelation stores value on the model's relation field by name — the setRelationField call
	// applyInverseRelationToCreated makes with the parent pointer (inverseParentRef). In memory
	// only. model and value must both be non-nil pointers; any other shape is the guard's no-op.
	SetRelation(model any, relation string, value any) error
	// PrimaryKey reads the model's primary key through the parsed schema — W10, the
	// parseSchema(model).PrimaryFields[0] read the has-family findOrNew found-check and the
	// touchIfTouching WHERE anchor make: the key column, whether the field holds its Go zero
	// (schemaField.ValueOf's flag — the "did Find populate dest" test) and whether the schema
	// carries a primary key at all (ok false: column "" and isZero true, the "no primary key"
	// branch). err is the schema parse error.
	PrimaryKey(model any) (column string, isZero bool, ok bool, err error)
}

type Descriptor struct {
	Name         string
	Kind         Kind
	ParentTable  string
	RelatedTable string
	RelatedModel any
	References   []ReferenceKey

	// many-to-many specifics
	PivotTable      string
	PivotParentRef  ReferenceKey
	PivotRelatedRef ReferenceKey
	// PivotField is the name of the field on the related model that the eager loader hydrates
	// with pivot column values. Sourced from Many2Many.PivotField (or the morph variants);
	// defaults to "Pivot". When the related model has no field by this name, no Pivot hydration
	// happens. The field's Go type drives both the SELECT list and hydration target.
	PivotField string
	// PivotCreatedAtColumn is the pivot-table column to auto-stamp with the current time on
	// INSERT. Empty string means "don't auto-stamp on INSERT". Resolved by the descriptor builder
	// from (priority): Pivot struct's autoCreateTime field → Pivot struct's CreatedAt field →
	// PivotTimestamps: true fallback (defaults to "created_at").
	PivotCreatedAtColumn string
	// PivotUpdatedAtColumn is the pivot-table column to auto-stamp with the current time on
	// INSERT and UPDATE. Empty string means "don't auto-stamp on INSERT/UPDATE". Same resolution
	// rules as pivotCreatedAtColumn but using autoUpdateTime / UpdatedAt.
	PivotUpdatedAtColumn string

	// RelatedKeyType is the Go type of the related model's PK field — used by castKey to normalise
	// SyncResult ids back to the related model's native key type, irrespective of what the caller
	// passed (string, int, uint, etc.) and what GORM scanned from the pivot table (often int64).
	// nil for kinds that don't have a related-side pivot key (HasOne family, BelongsTo, etc.).
	RelatedKeyType reflect.Type

	// polymorphic specifics
	MorphTypeColumn string // e.g. "imageable_type" — on parent table for MorphTo, on pivot for MorphToMany
	MorphIDColumn   string // e.g. "imageable_id"  — on parent table for MorphTo, on pivot for MorphToMany
	MorphValue      string // e.g. "post"          — used in WHERE *_type = ? filters
	MorphOwnerKey   string // PK on each related model for MorphTo (defaults to "id")
	MorphInverse    bool   // true for MorphedByMany — flips morph value source from parent to related

	// MorphTo per-type eager config and trashed-scope family — contractsorm.MorphTo's MorphWith /
	// MorphWithCount / Constrain / WithTrashed / WithoutTrashed / OnlyTrashed in declaration form.
	// loadMorphTo consumes them inside each bucket (the per-type query MorphTo::getResultsByType
	// builds) and newMorphToQuery applies the trashed family to the object-path read.
	MorphWith           map[string][]string
	MorphWithCount      map[string][]any
	MorphConstrain      map[string]contractsorm.RelationCallback
	MorphWithTrashed    bool
	MorphWithoutTrashed bool
	MorphOnlyTrashed    bool

	// through specifics
	ThroughTable   string
	FirstKey       string // FK on through pointing at parent
	SecondKey      string // FK on related pointing at through
	LocalKey       string // PK on parent
	SecondLocalKey string // PK on through

	// OnQuery is the per-relation default scope from Relation.OnQuery. Applied by every code
	// path that builds an inner query for this relation (eager loaders, existence builders,
	// Related), *before* any caller-supplied callback.
	OnQuery contractsorm.RelationCallback

	// WithDefault carries the WithDefault option of the BelongsTo / HasOne / MorphOne / MorphTo /
	// HasOneThrough descriptors:
	// nil (no default), bool, map[string]any, or func(related, parent any) any. The relation
	// default helpers in relation_defaults.go materialise it wherever a read finds no row.
	WithDefault any

	// Inverse is the related model's relation name that receives the parent instance after this
	// relation is read — HasOne / HasMany / MorphOne / MorphMany's Inverse field, i.e. Laravel's
	// ->Inverse('user') / ->chaperone(). The loaders write the parent back onto every related
	// model they match (and onto a WithDefault instance) under this name, and the relation read
	// path (Related) applies the same write-back to every model its reads return — the after-query
	// callback chaperone() registers, which runs on every execution of the relation query. An
	// empty string means no write-back. Validated at resolution against the related model's
	// Relations() map, like Eloquent's isRelation() check inside chaperone().
	Inverse string

	// OnPivotQuery is the per-relation default scope for pivot-table SELECT / UPDATE / DELETE,
	// from Many2Many.OnPivotQuery / MorphToMany.OnPivotQuery / MorphedByMany.OnPivotQuery.
	// Applied by existingPivotIDs, allPivotIDs, DetachRelation, UpdateExistingPivotRelation.
	OnPivotQuery contractsorm.PivotCallback

	// Touches, when true, makes Sync / Attach / Detach / Toggle / UpdateExistingPivot bump the
	// parent's updated_at after the pivot write succeeds (and only when pivot rows actually
	// changed). Source: Many2Many.Touches / MorphToMany.Touches / MorphedByMany.Touches.
	Touches bool

	// next link for Nested resolution (e.g. "Books.Author")
	Nested *Descriptor
}

type DescriptorSeam struct {
	// ParseModel parses a model's schema — parseSchema, with its OrmQueryInvalidModel /
	// OrmQueryTableNotSet errors.
	ParseModel func(model any) (ModelSchema, error)
	// TableOf resolves a model's declared table name without the connection prefix —
	// tableNameFor.
	TableOf func(model any) (string, error)
	// PivotFieldStructType reflects the related model for the struct field the pivot hydrates
	// into — pivotFieldStructType; ok is false when there is no such struct field.
	PivotFieldStructType func(relatedModel any, pivotFieldName string) (reflect.Type, bool)
	// HasRelationTag reports whether the model's field of the given name declares a GORM
	// relation tag — hasRelationTag.
	HasRelationTag func(model any, name string) bool
	// MorphValue resolves a model's morph alias through MorphClass() and the morph map, raising
	// under strict morph mode — database/orm/morphmap.MorphValue.
	MorphValue func(model any) (string, bool, error)
}

type EagerLoadEntry struct {
	Relation string                        // e.g. "Books" or "Books.Author"
	Columns  []string                      // pruned column list parsed from "Books:id,name"; nil = SELECT *
	Callback contractsorm.RelationCallback // nil for the synthetic noop entries that _addNestedWiths inserts
}

type Hooks struct {
	// ReadColumn reads the value of a DB column off the parent model. Builder.ColumnValue is its
	// Builder-level twin (W2) for the free functions the write workers port into.
	ReadColumn func(parent any, column string) (any, error)
	// ReadModelColumn reads the value of a DB column off a model instance the caller compares.
	ReadModelColumn func(model any, column string) (any, error)
	// ModelTable resolves a model instance's table name without the connection prefix ("" when
	// the model declares none).
	ModelTable func(model any) string
	// FirstRow runs the query as a single-row read into dest, reporting whether a row was found.
	FirstRow func(query contractsorm.Query, dest any) (bool, error)
	// BuildDefault materialises a WithDefault value into the default related instance for a
	// parent, reporting whether the value enables one. value is the relation's effective default —
	// the declaration's option as seeded into the projection (RelationInfo.WithDefault), replaced
	// by the object's call-time WithDefault call. nil reports false, the Go reading of Laravel's
	// falsy `if (! $this->withDefault) return;` gate.
	BuildDefault func(value any, parent any) (any, bool, error)
	// PendingAttributes reports the attributes the builder's WithAttributes recorded.
	PendingAttributes func() map[string]any
	// ModelConnection reads a model instance's declared connection name without connecting — the
	// value Eloquent's getConnectionName() reports ("" when the model declares none).
	ModelConnection func(model any) string
	// ModelKey reads a model instance's primary key value — the value Eloquent's getKey() reports —
	// for the one-of-many partial-relation guard.
	ModelKey func(model any) any
	// UpdatedAtColumn resolves the column the relation's Touch stamps: the related model's
	// automatic updated-at column, or "" when the model declares none.
	UpdatedAtColumn func() (string, error)
	// ModelCreatedAtColumn resolves a model's created-at column from its schema — the field the
	// write path stamps on insert. Relation::createdAt reads it off the parent model
	// (`$this->parent->getCreatedAtColumn()`, Relations/Relation.php:373; Eloquent's
	// Model::getCreatedAtColumn reports static::CREATED_AT, default "created_at"). "" when the
	// model declares none.
	ModelCreatedAtColumn func(model any) (string, error)
	// ModelUpdatedAtColumn resolves a model's updated-at column from its schema.
	// Relation::updatedAt reads it off the parent model (Relations/Relation.php:383; Eloquent's
	// Model::getUpdatedAtColumn reports static::UPDATED_AT). "" when the model declares none.
	ModelUpdatedAtColumn func(model any) (string, error)
	// IgnoringTouch reports whether the related model's class ignores touches — Eloquent's
	// Model::isIgnoringTouch() (no automatic updated-at column, or sitting in a WithoutTouching
	// ignore list).
	IgnoringTouch func() bool
}

type Kind int

type ModelSchema interface {
	// Table is the table the model maps to, without the connection prefix.
	Table() string
	// TypeName is the Go type name of the model, used in diagnostics.
	TypeName() string
	// ColumnType reports the Go type of the column and whether the schema carries it.
	ColumnType(column string) (reflect.Type, bool)
	// Columns lists the model's columns in declaration order.
	Columns() []SchemaColumn
	// ColumnByName looks a column up by its Go field name.
	ColumnByName(name string) (SchemaColumn, bool)
}

type MorphPivot struct {
	Pivot
	// contains filtered or unexported fields
}

type Pivot struct {
	// contains filtered or unexported fields
}

type PivotParentInfo struct {
	Connection      string
	CreatedAtColumn string
	UpdatedAtColumn string
}

type RefKey struct {
	PrimaryColumn string
	ForeignColumn string
}

type ReferenceKey struct {
	PrimaryTable  string
	PrimaryColumn string
	ForeignTable  string
	ForeignColumn string
}

type RelationInfo struct {
	Kind        Kind
	ParentTable string
	// ParentPrimaryKeyColumn is the parent (child, for the belongs-to kinds) model's own primary
	// key column — Eloquent's getKeyName() — the column BelongsTo / MorphTo
	// getQualifiedParentKeyName qualifies alongside ParentTable. Empty when the parent's schema
	// carries no primary key.
	ParentPrimaryKeyColumn string
	RelatedTable           string
	RelatedModel           any
	// RelatedConnection is the related model's declared connection name ("" when it declares
	// none) — the reference side of Eloquent's getConnectionName() comparison in Is. For MorphTo
	// it names the resolved morph class.
	RelatedConnection string
	References        []RefKey

	// WithDefault carries the WithDefault option of the single-result kinds: nil (no default),
	// bool, map[string]any or func(related, parent any) any. The field is the object's single
	// default slot — Eloquent's SupportsDefaultModels::$withDefault: the declaration seeds it, and
	// the object's call-time WithDefault call replaces it (setWithDefault).
	WithDefault any
	// Inverse carries the relation's declared inverse relation name — the related model's
	// relation that receives the parent instance on every read and on every write-created child
	// (Eloquent's ->inverse('user') / ->chaperone(); the name
	// SupportsInverseRelations::$inverseRelationship holds). "" when the relation was declared
	// without one. The write-back mechanics are engine-side: database/gorm installs the state on
	// the wrapped builder at wrap time. The projection seeds the object's GetInverseRelationship
	// answer and its WithoutChaperone / WithoutInverse clearing.
	Inverse string
	// OneOfMany reports that the relation's own scope turned it into a one-of-many relation.
	OneOfMany bool

	// polymorphic specifics
	MorphTypeColumn string
	MorphIDColumn   string
	MorphValue      string
	MorphOwnerKey   string
	MorphInverse    bool

	// through specifics
	ThroughTable string
	// FirstKey is the through table's foreign key to the far parent — HasOneOrManyThrough's
	// $firstKey, the column getQualifiedFirstKeyName qualifies with ThroughTable and the
	// non-existing-parent limit() partitions its group limit by.
	FirstKey       string
	SecondKey      string
	LocalKey       string
	SecondLocalKey string

	// many-to-many specifics
	PivotTable      string
	PivotParentRef  RefKey
	PivotRelatedRef RefKey

	// PivotField is the declared name of the struct field on the related model that m2m reads
	// hydrate with pivot column values — desc.pivotField (Many2Many.PivotField / the morph
	// variants, default "Pivot"). It is the Go stand-in for Eloquent's pivot accessor
	// (BelongsToMany::$accessor — 'pivot' in the class, BelongsToMany.php:145): GetPivotAccessor
	// reports it and As overrides it for the object's own reads. "" for the kinds that carry no
	// pivot.
	PivotField string

	// Name is the relation's declared name on the parent model — desc.name, the head segment of
	// the relation path the caller resolved: the relation method name Eloquent's
	// BelongsTo::getRelationName reports and the kind / FK error messages carry.
	Name string
	// Touches reports that the many-to-many declaration asked the pivot writes to bump the
	// parent's updated_at after a Sync / Attach / Detach / Toggle / UpdateExistingPivot that
	// changed rows — desc.touches (Many2Many.Touches / MorphToMany.Touches / MorphedByMany.Touches),
	// the declaration-time answer to BelongsToMany::touchIfTouching's touchingParent().
	Touches bool
	// PivotCreatedAtColumn / PivotUpdatedAtColumn name the pivot-table columns the pivot writes
	// stamp with the current time — both on insert, the updated one on update —
	// desc.pivotCreatedAtColumn / desc.pivotUpdatedAtColumn, resolved at declaration from the
	// Pivot struct's automatic timestamp fields or PivotTimestamps: true. "" leaves the column
	// unstamped (BelongsToMany::$withTimestamps false).
	PivotCreatedAtColumn string
	PivotUpdatedAtColumn string
	// RelatedKeyType is the Go type of the related model's primary key — desc.relatedKeyType —
	// the type the sync family casts its SyncResult ids back to (castKeys). nil for the kinds
	// without a related-side pivot key.
	RelatedKeyType reflect.Type
	// OnPivotQuery is the declaration's pivot-table scope (Many2Many.OnPivotQuery and the morph
	// variants) — desc.onPivotQuery, the callback the pivot-table SELECT / UPDATE / DELETE
	// primitives replay before compiling (applyOnPivotQueryToQuery). nil when none is declared.
	OnPivotQuery contractsorm.PivotCallback
}

type RowWhere struct {
	Query string
	Args  []any
}

type SchemaColumn struct {
	DBName         string
	FieldType      reflect.Type
	AutoCreateTime bool
	AutoUpdateTime bool
}