attrs

type Binder interface {
	// Bind binds the value to the model.
	BindToModel(model Definer, field Field) error
}

type CanCreateObject[T Definer] interface {
	// CreateObject creates a new object being the same
	// type as the source model provided in the method.
	//
	// This might be useful for creating new objects
	// when the embedder needs information from the source model,
	// such as the content type or other attributes.
	CreateObject(source T) T
}

type CanModelInfo interface {
	// ModelMetaInfo returns the meta information for the model.
	//
	// This is used to store information about the model, such as relational information,
	ModelMetaInfo(object Definer) map[string]any
}

type CanOnModelRegister interface {
	Field
	OnModelRegister(model Definer) error
}

type CanRelatedName interface {
	Field
	RelatedName() string
}

type CanReverseRelate interface {
	Field
	// ReverseRelate returns false, indicating that the field cannot be reverse related.
	AllowReverseRelation() bool
}

type CanSetup interface {
	Setup()
}

type CanSignalChanged interface {
	// Changed is a function that is called when a field is changed.
	//
	// This is used to notify the model that a field has changed,
	// so that the model can update its state accordingly.
	SignalChange(f Field, value interface{})

	// SignalReset is a function that should be called when a field saved, and thus the
	// changed status should be reset.
	SignalReset(f Field)
}

type DefaultGetter func(f Field, new_field_t_indirected reflect.Type, field_v reflect.Value) (interface{}, bool)

type Definer interface {
	// Retrieves the field definitions for the model.
	FieldDefs() Definitions
}

type Definitions interface {
	CanSignalChanged

	// Set sets the value of the field with the given name (or panics if not found).
	Set(name string, value interface{}) error

	// Retrieves the value of the field with the given name (or panics if not found).
	Get(name string) interface{}
	// contains filtered or unexported methods
}

type Embedded interface {
	BindToEmbedder(embedder Definer) error
}

type Embedder interface {
	// Embedded should return true if the field belongs to a model
	// that is embedded in another model.
	Embedded() bool
}

type Field interface {
	FieldDefinition

	// Scan the value of the field into your model.
	//
	// This allows for reading the value easily from the database.
	sql.Scanner

	// Return the value of the field as a driver.Value.
	//
	// This value should be used for storing the field in a database.
	//
	// If the field is nil or the zero value, the default value should be returned.
	driver.Valuer

	// FieldDefs retrieves the field definitions for the model.
	//
	// Each time a field is changed, the field definitions should receive a signal that
	// the field has changed.
	FieldDefinitions() Definitions

	// BindToDefinitions binds the field to the definitions of the model.
	//
	// This is used to bind the field to the model's definitions
	// so that the field can send the appropriate signals when the field is changed.
	BindToDefinitions(definitions Definitions)

	// ToString returns a string representation of the value.
	//
	// This should be the human-readable version of the value, for example for a list display.
	ToString() string

	// Retrieves the value of the field.
	GetValue() interface{}

	// Retrieves the default value of the field.
	GetDefault() interface{}

	// Sets the value of the field.
	//
	// If the field is not allowed to be edited and the force parameter is false, this method should panic.
	// If the field is not allowed to be null, this method should panic when trying to set the value to nil / a reflect.Invalid value.
	// If the field is not allowed to be blank, this method should panic when trying to set the value to a blank value if the field is not a primitive type.
	SetValue(v interface{}, force bool) error

	// Validates the field's value.
	Validate() error
}

type FieldConfig struct {
	AutoInit             bool                                                // Whether the parent struct should be initialized automatically if the field is an embedded field
	Null                 bool                                                // Whether the field allows null values
	Blank                bool                                                // Whether the field allows blank values
	ReadOnly             bool                                                // Whether the field is read-only
	Primary              bool                                                // Whether the field is a primary key
	Embedded             bool                                                // Whether the field is an embedded field
	NameOverride         string                                              // An optional override for the field name
	Label                any                                                 // The label for the field
	HelpText             any                                                 // The help text for the field
	Column               string                                              // The name of the column in the database
	MinLength            int64                                               // The minimum length of the field
	MaxLength            int64                                               // The maximum length of the field
	MinValue             float64                                             // The minimum value of the field
	MaxValue             float64                                             // The maximum value of the field
	Attributes           map[string]interface{}                              // The attributes for the field
	RelForeignKey        Relation                                            // The related object for the field (foreign key)
	RelManyToMany        Relation                                            // The related objects for the field (many to many, not implemented
	RelOneToOne          Relation                                            // The related object for the field (one to one, not implemented)
	RelForeignKeyReverse Relation                                            // The reverse foreign key for the field (not implemented)
	Default              any                                                 // The default value for the field (or a function that takes in the object type and returns the default value)
	Validators           []func(interface{}) error                           // Validators for the field
	FormField            func(opts ...func(fields.Field)) fields.Field       // The form field for the field
	WidgetAttrs          map[string]string                                   // The attributes for the widget
	FormWidget           func(FieldConfig) widgets.Widget                    // The form widget for the field
	Setter               func(Definer, interface{}) error                    // A custom setter for the field
	Getter               func(Definer) (interface{}, bool)                   // A custom getter for the field
	OnInit               func(Definer, *FieldDef, *FieldConfig) *FieldConfig // A function that is called when the field is initialized

}

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

type FieldDefinition interface {
	Name() string
	Labeler
	Helper

	// Tag retrieves the tag value for the field with the given name.
	Tag(name string) string

	// Retrieves the underlying model instance.
	//
	// For a field definition, this is likely not an actual instance of the model,
	// for the Field interface, this is the actual model instance.
	Instance() Definer

	// ColumnName retrieves the name of the column in the database.
	//
	// This can be used to generate the SQL for the field.
	ColumnName() string

	// Type returns the reflect.Type of the field.
	Type() reflect.Type

	// Attrs returns any extra attributes for the field, these can be used for multiple purposes.
	//
	// Additional info can be stored here, for example - if the field has a min / max length.
	Attrs() map[string]any

	// Rel etrieves the related model instance for a foreign key field.
	//
	// This could be used to generate the SQL for the field.
	Rel() Relation

	// Reports whether the field is the primary field.
	//
	// A model can technically have multiple primary fields, but this is not recommended.
	//
	// When for example, calling `Primary()` on the `Definitions` interface - only one will be returned.
	IsPrimary() bool

	// Reports whether the field is allowed to be null.
	//
	// If not, the field should panic when trying to set the value to nil / a reflect.Invalid value.
	AllowNull() bool

	// Reports whether the field is allowed to be blank.
	//
	// If not, the field should panic when trying to set the value to a blank value if the field is not of types:
	// bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128.
	//
	// this means that for example, a string field should panic when trying to set the value to an empty string.
	AllowBlank() bool

	// Reports whether the field is allowed to be edited.
	//
	// If not, the field should panic when trying to set the value, unless the force parameter passed to the `SetValue` method is true.
	AllowEdit() bool

	// Retrieves the form field for the field.
	//
	// This is used to generate forms for the field.
	FormField() fields.Field
}

type FieldUnpackerMixin interface {
	ObjectFields(object Definer, base_fields *FieldsMap) error
}

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

type FormFieldGetter func(f Field, new_field_t_indirected reflect.Type, field_v reflect.Value, opts ...func(fields.Field)) (fields.Field, bool)

type Function interface{}

type Helper interface {
	// HelpText returns a description of the field.
	//
	// This is displayed to the user in for example, forms.
	HelpText(ctx context.Context) string
}

type Labeler interface {
	// Label returns the human-readable name of the field.
	//
	// This is the name that is displayed to the user in for example, forms and column headers.
	Label(ctx context.Context) string
}

type LazyRelation interface {
	Relation

	// ModelKey returns the key of the model in the lazy registry.
	ModelKey() string
}

type LazyThrough interface {
	Through

	// ModelKey returns the key of the model in the lazy registry.
	ModelKey() string
}

type ModelMeta interface {
	// Model returns the model for this meta
	Model() Definer

	// Forward returns the forward relations for this model
	// which belong to the field with the given name.
	Forward(relField string) (Relation, bool)

	// Reverse returns the reverse relations for this model
	// which belong to the field with the given name.
	Reverse(relField string) (Relation, bool)

	// ForwardMap returns a copy the forward relations map for this model
	ForwardMap() *orderedmap.OrderedMap[string, Relation]

	// ReverseMap returns a copy of the reverse relations map for this model
	ReverseMap() *orderedmap.OrderedMap[string, Relation]

	// ContentType returns the content type for the model.
	ContentType() contenttypes.ContentType

	// Storage returns a value stored on the model meta.
	//
	// This is used to store values that are not part of the model itself,
	// but are needed for the model or possible third party libraries to function.
	//
	// Values can be stored on the model meta using the `attrs.StoreOnMeta` helper function.
	//
	// A model can also implement the `CanModelInfo` interface to store values on the model meta.
	Storage(key string) (any, bool)

	// Definitions returns the field definitions for the model.
	//
	// This is used to retrieve meta information about fields, such as their type,
	// and other information that is not part of the model itself.
	Definitions() StaticDefinitions
}

type ObjectDefinitions struct {
	Object       Definer
	PrimaryField string
	Table        string
	ObjectFields *FieldsMap
	// contains filtered or unexported fields
}

type PathMetaChain []*pathMeta

type Relation interface {
	RelationTarget

	Type() RelationType

	// A through model for the relationship.
	//
	// This can be nil, but does not have to be.
	// It can support a one to one relationship with or without a through model,
	// or a many to many relationship with a through model.
	Through() Through
}

type RelationChain struct {
	Root   *RelationChainPart
	Final  *RelationChainPart
	Fields []FieldDefinition
	Chain  []string
}

type RelationChainPart struct {
	Next      *RelationChainPart // the next part in the chain
	Prev      *RelationChainPart // the previous part in the chain
	ChainPart string             // the name of the field in the chain
	FieldRel  Relation           // the relation of the field in the current part
	Model     Definer            // the current target model
	Through   Through            // the through relation to get to the target model, if any
	Field     FieldDefinition    // the field in the current model, possibly containing the next relation
	Depth     int                // corresponds to the index in chain.Chain
	// contains filtered or unexported fields
}

type RelationTarget interface {
	// From represents the source model for the relationship.
	//
	// If this is nil then the current interface value is the source model.
	From() RelationTarget

	// The target model for the relationship.
	Model() Definer

	// Field retrieves the field in the target model for the relationship.
	//
	// This can be nil, in such cases the relationship should use the primary field of the target model.
	//
	// If a through model is used, the target field should still target the actual target model,
	// the through model should then use this field to link to the target model.
	Field() FieldDefinition
}

type RelationType int

type Scanner interface {
	// ScanAttribute scans the value of the attribute.
	//
	// This is used to set the value of the field from a raw value.
	ScanAttribute(src any) error
}

type SignalModelMeta struct {
	Definer     Definer
	Definitions StaticDefinitions
	Meta        ModelMeta
}

type SignalThroughModelMeta struct {
	Source      Definer
	Target      Definer
	ThroughInfo Through
	Meta        ModelMeta
}

type StaticDefinitions = staticDefinitions[FieldDefinition]

type Through interface {
	// The through model itself.
	Model() Definer

	// The source field for the relation - this is a field in the through model linking to the source model.
	SourceField() string

	// The target field for the relation - this is a field in the through model linking to the target model.
	TargetField() string
}

type ThroughMeta struct {
	IsThroughModel bool
	Source         Definer
	Target         Definer
	SourceField    string
	TargetField    string
}

type ThroughModel struct {
	This   Definer
	Source string
	Target string
}

type ToBoolConverter interface {
	ToBool() bool
}

type ToFloatConverter interface {
	ToFloat() float64
}

type ToIntConverter interface {
	ToInt() int64
}

type ToStringConverter interface {
	ToString() string
}

type ToTimeConverter interface {
	ToTime() time.Time
}

type UnboundField interface {
	Field
	UnboundFieldConstructor
}

type UnboundFieldConstructor interface {
	// Name returns the name of the field.
	Name() string

	// BindField binds the field to the model.
	BindField(model Definer) (Field, error)
}

type WalkFieldsFunc func(source Relation, meta ModelMeta, object Definer, field FieldDefinition, fieldRel Relation, part string, parts []string, idx int) (stop bool, err error)