orm

type ArrayColumn[T any] struct {
	Column[[]T]
}

type BelongsTo[TSource any, TTarget any, PK comparable] struct {
	// contains filtered or unexported fields
}

type BoolColumn struct {
	Column[bool]
}

type BulkUpdateOptions struct {
	UpdateColumns []string // Columns to update (if empty, updates all non-primary key columns)
	WhereColumns  []string // Columns to match on for WHERE clause (if empty, uses primary keys)
}

type Column[T any] struct {
	Name  string
	Table string
}

type ColumnMetadata struct {
	FieldName       string              // Go struct field name
	DBName          string              // Database column name
	DBType          string              // Database type
	GoType          string              // Go type
	IsPrimaryKey    bool                // Is this a primary key?
	IsAutoGenerated bool                // Is this auto-generated (serial, default:now(), etc)?
	IsNullable      bool                // Can this be NULL?
	IsUnique        bool                // Has unique constraint?
	IsPointer       bool                // Is this a pointer field in Go struct?
	Default         string              // Default value
	Tags            map[string]string   // All dbdef tags
	Constraints     []string            // Check constraints
	ForeignKey      *ForeignKeyMetadata // Foreign key info if applicable

	// Generated accessor functions for zero-reflection field access
	GetValue func(model interface{}) interface{} // Extract field value (handles pointer dereferencing)
	IsNil    func(model interface{}) bool        // Check if pointer field is nil (only for pointer fields)
}

type Comparable interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64 |
		~string |
		time.Time
}

type ComparableColumn[T Comparable] struct {
	Column[T]
}

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

type DBExecutor interface {
	// Query execution methods
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
	QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
	QueryxContext(ctx context.Context, query string, args ...interface{}) (*sqlx.Rows, error)
	QueryRowxContext(ctx context.Context, query string, args ...interface{}) *sqlx.Row

	// Get and Select for struct scanning
	GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error
	SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

	// Named query support
	NamedExecContext(ctx context.Context, query string, arg interface{}) (sql.Result, error)

	// Prepared statements
	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
	PreparexContext(ctx context.Context, query string) (*sqlx.Stmt, error)
	PrepareNamedContext(ctx context.Context, query string) (*sqlx.NamedStmt, error)

	// Rebind for driver-specific placeholders
	Rebind(query string) string

	// DriverName returns the driverName passed to the Open function for this DB.
	DriverName() string
}

type DBWrapper interface {
	DBExecutor
	BeginTxx(ctx context.Context, opts *sql.TxOptions) (*sqlx.Tx, error)
	Close() error
	Ping() error
	PingContext(ctx context.Context) error
	Stats() sql.DBStats
}

type Error struct {
	Op         string        // Operation that failed
	Table      string        // Table involved
	Err        error         // Underlying error
	Query      string        // SQL query (if applicable)
	Args       []interface{} // Query arguments (if applicable)
	Constraint string        // Constraint name (if applicable)
	Column     string        // Column name (if applicable)
	Retryable  bool          // Whether the operation can be retried
}

type ForeignKeyMetadata struct {
	ReferencedTable  string
	ReferencedColumn string
	OnDelete         string
	OnUpdate         string
}

type HasMany[TSource any, TTarget any, PK comparable] struct {
	// contains filtered or unexported fields
}

type HasManyThrough[TSource any, TTarget any, TJoin any, PK comparable] struct {
	// contains filtered or unexported fields
}

type HasOne[TSource any, TTarget any, PK comparable] struct {
	// contains filtered or unexported fields
}

type JSONBColumn struct {
	Column[interface{}]
}

type JSONData struct {
	json.RawMessage
}

type JoinType string

type MiddlewareContext struct {
	Operation    OperationType
	TableName    string
	Record       interface{}
	Records      interface{}
	QueryBuilder interface{} // squirrel.SelectBuilder, squirrel.InsertBuilder, etc.
	Query        string
	Args         []interface{}
	Error        error
	StartTime    time.Time
	Duration     time.Duration
	Context      context.Context
	Metadata     map[string]interface{}
}

type ModelMetadata struct {
	// Basic table information
	TableName  string
	StructName string

	// Column mappings
	Columns    map[string]*ColumnMetadata // key is Go field name
	ColumnMap  map[string]string          // Go field -> DB column
	ReverseMap map[string]string          // DB column -> Go field

	// Primary keys only - other column lists are determined dynamically
	PrimaryKeys []string // DB column names

	// Relationships
	Relationships map[string]*RelationshipMetadata
}

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64
}

type NumericColumn[T Numeric] struct {
	ComparableColumn[T]
}

type OperationType string

type Query[T any] struct {
	// contains filtered or unexported fields
}

type QueryMiddleware func(next QueryMiddlewareFunc) QueryMiddlewareFunc

type QueryMiddlewareFunc func(ctx *MiddlewareContext) error

type RelationshipMetadata struct {
	Name       string
	Type       string // belongs_to, has_one, has_many, has_many_through
	Target     string // Target model name
	ForeignKey string // Foreign key field
	TargetKey  string // Target key field (for belongs_to)
	SourceKey  string // Source key field (for has_one/has_many)
	Through    string // Through model (for has_many_through)
	ThroughFK  string // Through foreign key
	ThroughTK  string // Through target key

	// Generated accessor functions for relationships
	SetValue func(model interface{}, value interface{}) // Set relationship value
	IsSlice  bool                                       // Whether this is a slice relationship
}

type Repository[T any] struct {
	// contains filtered or unexported fields
}

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

type StringColumn struct {
	Column[string]
}

type Table struct {
	Name        string   `json:"name"`
	PrimaryKeys []string `json:"primary_keys"`
	Schema      string   `json:"schema,omitempty"`
}

type TimeColumn struct {
	ComparableColumn[time.Time]
}

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

type TransactionOptions struct {
	Isolation sql.IsolationLevel
	ReadOnly  bool
}

type UpsertOptions struct {
	ConflictColumns []string          // Columns that define conflicts (ON CONFLICT)
	UpdateColumns   []string          // Columns to update on conflict (if empty, updates all non-conflict columns)
	UpdateExpr      map[string]string // Custom update expressions (column -> expression)
}

type ValidationError struct {
	Field   string
	Message string
}

type ValidationErrors []ValidationError