domain

type AccountConfig struct {
	// ModelName is the model name for the account
	ModelName string

	// Fields maps field names to different column names
	Fields map[string]string

	// EncryptOAuthTokens encrypts OAuth tokens before storing them (default: false)
	EncryptOAuthTokens bool

	// UpdateAccountOnSignIn updates account data on sign in with latest data from provider
	UpdateAccountOnSignIn bool

	// AccountLinking configuration
	AccountLinking *AccountLinkingConfig
}

type AccountLinkingConfig struct {
	// Enabled enables account linking (default: false)
	Enabled bool

	// TrustedProviders is a list of trusted providers
	TrustedProviders []string

	// AllowDifferentEmails allows users to link accounts with different email addresses
	AllowDifferentEmails bool

	// AllowUnlinkingAll allows users to unlink all accounts
	AllowUnlinkingAll bool
}

type AdditionalField struct {
	Type string
}

type AdvancedConfig struct {
	// IPAddress configuration for rate limiting and session tracking
	IPAddress *IPAddressConfig

	// UseSecureCookies uses secure cookies (default: false)
	UseSecureCookies bool

	// DisableCSRFCheck disables trusted origins check (⚠️ security risk)
	DisableCSRFCheck bool

	// CrossSubDomainCookies configures cookies to be shared across subdomains
	CrossSubDomainCookies *CrossSubDomainCookiesConfig

	// Cookies allows customizing cookie names and attributes
	Cookies map[string]CookieConfig

	// DefaultCookieAttributes sets default attributes for all cookies
	DefaultCookieAttributes *CookieAttributes

	// CookiePrefix is a prefix for all cookies
	CookiePrefix string

	// Database holds advanced database configuration
	Database *DatabaseAdvancedConfig
}

type AuthError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
	Status  int    `json:"status"`
}

type CRUDHooks struct {
	Before func(ctx context.Context, data interface{}) (interface{}, error)
	After  func(ctx context.Context, result interface{}) error
}

type ChangeEmailConfig struct {
	// Enabled enables the change email feature (default: false)
	Enabled bool

	// SendChangeEmailVerification is a function to send change email verification
	SendChangeEmailVerification func(ctx context.Context, user *user.User, newEmail string, url string, token string) error
}

type Config struct {
	// AppName is the name of the application
	AppName string

	// BaseURL is the base URL for Better Auth (e.g., "https://example.com")
	// If not set, will check GO_BETTER_AUTH_URL environment variable
	BaseURL string

	// BasePath is the base path for Better Auth routes (default: "/api/auth")
	// Will be overridden if there is a path component within BaseURL
	BasePath string

	// TrustedOrigins is a list of trusted origins for CORS
	// Supports static origins, dynamic origins via function, and wildcard patterns
	TrustedOrigins TrustedOriginsConfig

	// Secret is used for encryption, signing, and hashing
	// If not set, will check GO_BETTER_AUTH_SECRET or AUTH_SECRET environment variables
	// In production, if not set, will throw an error
	Secret string

	// Database configuration
	Database DatabaseConfig

	// Secondary Storage
	SecondaryStorage storage.SecondaryStorage

	// EmailAndPassword authentication configuration
	EmailAndPassword *EmailPasswordConfig

	// EmailVerification configuration
	EmailVerification *EmailVerificationConfig

	// SocialProviders configuration
	SocialProviders *SocialProvidersConfig

	// Plugins is a list of Better Auth plugins
	Plugins []Plugin

	// User configuration options
	User *UserConfig

	// Session configuration options
	Session *SessionConfig

	// Account configuration options
	Account *AccountConfig

	// Verification configuration options
	Verification *VerificationConfig

	// RateLimit configuration
	RateLimit *RateLimitOptions

	// BruteForce configuration
	BruteForce *security.BruteForceConfig

	// Advanced configuration options
	Advanced *AdvancedConfig

	// Logger configuration
	Logger *LoggerConfig

	// DatabaseHooks for lifecycle events
	DatabaseHooks *DatabaseHooksConfig

	// OnAPIError configuration
	OnAPIError *OnAPIErrorConfig

	// Hooks for request lifecycle
	Hooks *HooksConfig

	// DisabledPaths is a list of paths to disable
	DisabledPaths []string
}

type ConfigValidationResult struct {
	Valid  bool
	Errors []ValidationError
}

type CookieAttributes struct {
	HTTPOnly bool
	Secure   bool
	SameSite string
	Path     string
	Domain   string
	MaxAge   int
}

type CookieCacheConfig struct {
	// Enabled enables caching session in cookie (default: false)
	Enabled bool

	// MaxAge is the cache duration in seconds (default: 300 - 5 minutes)
	MaxAge int
}

type CookieConfig struct {
	Name       string
	Attributes CookieAttributes
}

type CrossSubDomainCookiesConfig struct {
	// Enabled enables cross subdomain cookies
	Enabled bool

	// AdditionalCookies is a list of additional cookies to share across subdomains
	AdditionalCookies []string

	// Domain is the domain for the cookies
	Domain string
}

type DatabaseAdvancedConfig struct {
	// UseNumberId uses auto-incrementing IDs instead of UUIDs
	UseNumberId bool

	// GenerateId is a custom ID generator function, or false to disable ID generation
	GenerateId interface{} // func(model string, size int) string or false

	// DefaultFindManyLimit is the default limit for findMany queries
	DefaultFindManyLimit int
}

type DatabaseConfig struct {
	// Provider is the database option ("sqlite", "postgres")
	Provider string

	// ConnectionString is the database connection string
	ConnectionString string

	// LogQueries enables SQL query logging for debugging (default: false)
	LogQueries bool

	// MaxOpenConns sets the maximum number of open connections to the database (default: 25)
	MaxOpenConns int

	// MaxIdleConns sets the maximum number of idle connections (default: 5)
	MaxIdleConns int

	// ConnMaxLifetime sets the maximum amount of time a connection may be reused in seconds (default: 3600)
	ConnMaxLifetime int
}

type DatabaseHooksConfig struct {
	User         *ModelHooks
	Session      *ModelHooks
	Account      *ModelHooks
	Verification *ModelHooks
}

type DeleteUserConfig struct {
	// Enabled enables the delete user feature (default: false)
	Enabled bool

	// SendDeleteAccountVerification is a function to send delete account verification
	SendDeleteAccountVerification func(ctx context.Context, user *user.User, url string, token string) error

	// BeforeDelete is called before user deletion
	BeforeDelete func(ctx context.Context, user *user.User) error

	// AfterDelete is called after user deletion
	AfterDelete func(ctx context.Context, user *user.User) error
}

type DiscordProviderConfig struct {
	ClientID     string
	ClientSecret string
	RedirectURI  string
}

type EmailPasswordConfig struct {
	// Enabled enables email and password authentication (default: false)
	Enabled bool

	// DisableSignUp disables email and password sign up (default: false)
	DisableSignUp bool

	// RequireEmailVerification requires email verification before session creation
	RequireEmailVerification bool

	// MinPasswordLength is the minimum password length (default: 8)
	MinPasswordLength int

	// MaxPasswordLength is the maximum password length (default: 128)
	MaxPasswordLength int

	// AutoSignIn automatically signs in the user after sign up
	AutoSignIn bool

	// SendResetPassword is a function to send reset password emails
	SendResetPassword func(ctx context.Context, user *user.User, url string, token string) error

	// ResetPasswordTokenExpiresIn is the duration the reset token is valid for (default: 1 hour)
	ResetPasswordTokenExpiresIn time.Duration

	// Password holds custom password hashing and verification functions
	Password *PasswordConfig
}

type EmailVerificationConfig struct {
	// Enabled enables email verification feature (default: false)
	Enabled bool

	// SendVerificationEmail is a function to send verification emails
	SendVerificationEmail func(ctx context.Context, user *user.User, url string, token string) error

	// SendOnSignUp automatically sends verification email after sign up (default: false)
	SendOnSignUp bool

	// SendOnSignIn sends verification email on sign in when user's email is not verified (default: false)
	SendOnSignIn bool

	// AutoSignInAfterVerification automatically signs in the user after email verification
	AutoSignInAfterVerification bool

	// ExpiresIn is the duration the verification token is valid for (default: 1 hour)
	ExpiresIn time.Duration
}

type GitHubProviderConfig struct {
	ClientID     string
	ClientSecret string
	RedirectURI  string
}

type GoogleProviderConfig struct {
	ClientID     string
	ClientSecret string
	RedirectURI  string
}

type HookResponse struct {
	// Context contains the modified context to be merged with the original
	Context *RequestContext
}

type HooksConfig struct {
	// Before is executed before processing the request.
	// It receives the request context and can return a modified context.
	// If it returns an error, the request is blocked.
	Before func(ctx *RequestContext) (*HookResponse, error)

	// After is executed after processing the request.
	// It receives the request context and can return a modified context.
	// Errors are silently handled to avoid disrupting responses.
	After func(ctx *RequestContext) (*HookResponse, error)
}

type IPAddressConfig struct {
	// IPAddressHeaders is a list of headers to check for IP address
	IPAddressHeaders []string

	// DisableIpTracking disables IP tracking
	DisableIpTracking bool
}

type LogLevel string

type LoggerConfig struct {
	// Disabled disables all logging (default: false)
	Disabled bool

	// DisableColors disables colors in the default logger (default: auto-detected)
	DisableColors bool

	// Level is the minimum log level to display
	Level LogLevel

	// Log is a custom logging function
	Log func(level LogLevel, message string, args ...any)
}

type MigrationInfo struct {
	CurrentVersion uint `json:"current_version"`
	Dirty          bool `json:"dirty"`
}

type MigrationService interface {
	// Up runs all pending migrations
	Up(ctx context.Context) error

	// Down runs one migration down
	Down(ctx context.Context) error

	// Steps runs n migrations up (positive) or down (negative)
	Steps(ctx context.Context, n int) error

	// Version returns the current migration version and dirty state
	Version(ctx context.Context) (uint, bool, error)

	// Force sets the migration version without running migrations
	Force(ctx context.Context, version int) error

	// Drop drops all tables and schema
	Drop(ctx context.Context) error

	// GetMigrationInfo returns information about migration status
	GetMigrationInfo(ctx context.Context) (*MigrationInfo, error)

	// Close closes the migration instance
	Close() error
}

type ModelHooks struct {
	Create *CRUDHooks
	Update *CRUDHooks
}

type OnAPIErrorConfig struct {
	// Throw throws an error on API error (default: false)
	Throw bool

	// OnError is a custom error handler
	OnError func(err error, ctx context.Context)

	// ErrorURL is the URL to redirect to on error (default: "/api/auth/error")
	ErrorURL string
}

type PasswordConfig struct {
	// Hash is a custom password hashing function
	Hash func(password string) (string, error)

	// Verify is a custom password verification function
	Verify func(password, hash string) bool
}

type Plugin interface {
	Name() string
	Initialize(config any) error
}

type RateLimitOptions struct {
	// Enabled enables rate limiting (defaults: true in production, false in development)
	Enabled bool

	// Window is the time window in seconds (default: 10)
	Window int

	// Max is the maximum number of requests allowed within the window (default: 100)
	Max int

	// Algorithm specifies the rate limiting algorithm to use
	// Options: "fixed-window" (default), "sliding-window"
	// Fixed window: Simple counter that resets at window boundaries
	// Sliding window: Weighted counter using current and previous window for smoother limiting
	Algorithm string

	// CustomRules defines custom rate limit rules for specific paths
	CustomRules map[string]RateLimitRule

	// Storage defines the storage type ("memory", "database", "secondary-storage")
	Storage string

	// ModelName is the name of the table for rate limiting if database is used (default: "rateLimit")
	ModelName string
}

type RateLimitRule struct {
	Window int
	Max    int
}

type RedisConfig struct {
	// Host is the Redis server host (default: "localhost")
	Host string

	// Port is the Redis server port (default: 6379)
	Port int

	// DB is the Redis database number (default: 0)
	DB int

	// Password is the Redis password (optional)
	Password string

	// TLS enables TLS connection to Redis (default: false)
	TLS bool

	// MaxRetries is the maximum number of retries (default: 3)
	MaxRetries int

	// PoolSize is the connection pool size (default: 10)
	PoolSize int
}

type RequestContext struct {
	// Path is the URL path of the request (e.g., "/auth/signin")
	Path string
	// Method is the HTTP method of the request (GET, POST, etc.)
	Method string
	// Body contains the parsed request body (for POST/PUT requests)
	Body any
	// Headers contains the request headers
	Headers map[string][]string
	// Query contains query parameters from the URL
	Query map[string][]string
	// Request is the underlying *http.Request object
	Request *http.Request
	// Context contains auth-related context like session, config, etc.
	Context map[string]any
}

type SessionConfig struct {
	// ModelName is the model name for the session (default: "session")
	ModelName string

	// Fields maps field names to different column names
	Fields map[string]string

	// ExpiresIn is the expiration time for the session token in seconds (default: 604800 - 7 days)
	ExpiresIn time.Duration

	// UpdateAge is how often the session should be refreshed in seconds (default: 86400 - 1 day)
	UpdateAge time.Duration

	// DisableSessionRefresh disables session refresh (default: false)
	DisableSessionRefresh bool

	// AdditionalFields defines additional fields for the session table
	AdditionalFields map[string]AdditionalField

	// StoreSessionInDatabase stores session in database when secondary storage is provided (default: false)
	StoreSessionInDatabase bool

	// PreserveSessionInDatabase preserves session records in database when deleted from secondary storage (default: false)
	PreserveSessionInDatabase bool

	// CookieCache enables caching session in cookie
	CookieCache *CookieCacheConfig
}

type SocialProvidersConfig struct {
	Google  *GoogleProviderConfig
	GitHub  *GitHubProviderConfig
	Discord *DiscordProviderConfig
}

type TrustedOriginsConfig struct {
	// StaticOrigins is a static list of trusted origins
	StaticOrigins []string

	// DynamicOrigins is a function that returns origins dynamically based on the request
	DynamicOrigins func(r *http.Request) []string
}

type UserConfig struct {
	// ModelName is the model name for the user (default: "user")
	ModelName string

	// Fields maps field names to different column names
	Fields map[string]string

	// AdditionalFields defines additional fields for the user table
	AdditionalFields map[string]AdditionalField

	// ChangeEmail configuration
	ChangeEmail *ChangeEmailConfig

	// DeleteUser configuration
	DeleteUser *DeleteUserConfig
}

type ValidationError struct {
	Field   string
	Message string
}

type VerificationConfig struct {
	// ModelName is the model name for the verification table
	ModelName string

	// Fields maps field names to different column names
	Fields map[string]string

	// DisableCleanup disables cleaning up expired values when a verification value is fetched
	DisableCleanup bool
}