mail

type Attachment struct {
	// Filename is the name of the file
	Filename string `json:"filename"`
	// ContentType is the MIME content type
	ContentType string `json:"content_type"`
	// Content is the file content
	Content []byte `json:"content,omitempty"`
	// Reader is an alternative to Content for streaming large files
	Reader io.Reader `json:"-"`
	// Size is the size of the attachment in bytes
	Size int64 `json:"size"`
	// Inline indicates if the attachment should be displayed inline
	Inline bool `json:"inline"`
	// ContentID is used for inline attachments
	ContentID string `json:"content_id,omitempty"`
}

type AuthMethod string

type Backend interface {
	NewSession(conn *Conn) (Session, error)
}

type ClientConfig struct {
	Enabled bool `yaml:"enabled" json:"enabled"`
	// Host is the SMTP server hostname
	Host string `yaml:"host" json:"host"`
	// Port is the SMTP server port
	Port int `yaml:"port" json:"port"`
	// Username for SMTP authentication
	Username string `yaml:"username" json:"username"`
	// Password for SMTP authentication
	Password string `yaml:"password" json:"password"`
	// From address for outgoing emails
	From string `yaml:"from" json:"from"`
	// FQDN for HELO command
	FQDN string `yaml:"fqdn" json:"fqdn"`
	// Authentication enabled
	Auth bool `yaml:"auth" json:"auth"`
	// AuthMethod defines the authentication method (PLAIN, CRAMMD5, LOGIN)
	AuthMethod string `yaml:"auth_method" json:"auth_method"`
	// Encryption method (NONE, STARTTLS, TLS)
	Encryption string `yaml:"encryption" json:"encryption"`
	// SkipCertificateVerification skips TLS certificate verification
	SkipCertificateVerification bool `yaml:"skip_cert_verification" json:"skip_cert_verification"`
	// Timeout for SMTP operations
	Timeout time.Duration `yaml:"timeout" json:"timeout"`
	// MaxRetries for failed email sending
	MaxRetries int `yaml:"max_retries" json:"max_retries"`
	// RetryDelay between retries
	RetryDelay time.Duration `yaml:"retry_delay" json:"retry_delay"`
}

type Config struct {
	// SMTP Client Configuration
	Client ClientConfig `yaml:"client" json:"client"`
	// SMTP Server Configuration
	Server ServerConfig `yaml:"server" json:"server"`
	// Queue Configuration
	Queue QueueConfig `yaml:"queue" json:"queue"`
	// Templates Configuration
	Templates TemplateConfig `yaml:"templates" json:"templates"`
}

type Conn struct {
	net.Conn
	// contains filtered or unexported fields
}

type EncryptionMethod string

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

type Manager struct {
	TemplateManager *TemplateManager
	// contains filtered or unexported fields
}

type Message struct {
	// ID is a unique identifier for the message
	ID string `json:"id"`
	// From is the sender's email address
	From string `json:"from"`
	// To is a list of recipient email addresses
	To []string `json:"to"`
	// CC is a list of carbon copy recipient email addresses
	CC []string `json:"cc,omitempty"`
	// BCC is a list of blind carbon copy recipient email addresses
	BCC []string `json:"bcc,omitempty"`
	// ReplyTo is the reply-to email address
	ReplyTo string `json:"reply_to,omitempty"`
	// Subject is the email subject
	Subject string `json:"subject"`
	// TextBody is the plain text body of the email
	TextBody string `json:"text_body,omitempty"`
	// HTMLBody is the HTML body of the email
	HTMLBody string `json:"html_body,omitempty"`
	// Template is the name of the template to use
	Template string `json:"template,omitempty"`
	// TemplateContent is the direct template content to use (alternative to Template)
	TemplateContent string `json:"template_content,omitempty"`
	// TemplateData is the data to pass to the template
	TemplateData interface{} `json:"template_data,omitempty"`
	// TemplateFuncs contains template functions specific to this message (optional)
	TemplateFuncs template.FuncMap `json:"-"`
	// Attachments is a list of file attachments
	Attachments []Attachment `json:"attachments,omitempty"`
	// Headers contains additional email headers
	Headers map[string]string `json:"headers,omitempty"`
	// Priority is the message priority
	Priority Priority `json:"priority"`
	// CreatedAt is when the message was created
	CreatedAt time.Time `json:"created_at"`
	// ScheduleAt is when the message should be sent (optional)
	ScheduleAt *time.Time `json:"schedule_at,omitempty"`
	// Metadata contains additional metadata
	Metadata map[string]string `json:"metadata,omitempty"`
}

type MessageBuilder struct {
	Error error // Error is used to capture any errors during building
	// contains filtered or unexported fields
}

type NotificationHandler func(ctx context.Context, from string, to []string, data io.Reader) error

type Options struct {
	Size int64
	Body string
	UTF8 bool
}

type Priority int

type QueueConfig struct {
	// Enabled indicates if queue processing should be used
	Enabled bool `yaml:"enabled" json:"enabled"`
	// WorkerCount is the number of workers processing mail jobs
	WorkerCount int `yaml:"worker_count" json:"worker_count"`
	// QueueName is the name of the queue for mail jobs
	QueueName string `yaml:"queue_name" json:"queue_name"`
	// Priority for mail jobs
	Priority int `yaml:"priority" json:"priority"`
	// MaxAttempts for failed mail jobs
	MaxAttempts int `yaml:"max_attempts" json:"max_attempts"`
	// JobTimeout for mail job processing
	JobTimeout time.Duration `yaml:"job_timeout" json:"job_timeout"`
}

type RcptOptions struct {
	Notify string
}

type Recipient struct {
	// Email is the recipient's email address
	Email string `json:"email"`

	// Name is the recipient's display name
	Name string `json:"name,omitempty"`

	// Type is the recipient type (to, cc, bcc)
	Type string `json:"type"`
}

type SecurityConfig struct {
	// HeloValidation enables HELO/EHLO hostname validation
	HeloValidation bool `yaml:"helo_validation" json:"helo_validation"`
	// HeloRequireFQDN requires HELO hostname to be a fully qualified domain name
	HeloRequireFQDN bool `yaml:"helo_require_fqdn" json:"helo_require_fqdn"`
	// HeloDNSCheck enables DNS resolution check for HELO hostname
	HeloDNSCheck bool `yaml:"helo_dns_check" json:"helo_dns_check"`
	// IPAllowlist contains allowed IP addresses/CIDR blocks
	IPAllowlist []string `yaml:"ip_allowlist" json:"ip_allowlist"`
	// IPBlocklist contains blocked IP addresses/CIDR blocks
	IPBlocklist []string `yaml:"ip_blocklist" json:"ip_blocklist"`
	// MaxConnectionsPerIP limits connections per IP address
	MaxConnectionsPerIP int `yaml:"max_connections_per_ip" json:"max_connections_per_ip"`
	// RateLimitPerIP limits commands per IP per minute
	RateLimitPerIP int `yaml:"rate_limit_per_ip" json:"rate_limit_per_ip"`
	// AuthFailureDelay adds delay after authentication failures
	AuthFailureDelay time.Duration `yaml:"auth_failure_delay" json:"auth_failure_delay"`
	// MaxAuthFailures limits auth attempts before blocking IP
	MaxAuthFailures int `yaml:"max_auth_failures" json:"max_auth_failures"`
	// AuthFailureWindow is the time window to track auth failures
	AuthFailureWindow time.Duration `yaml:"auth_failure_window" json:"auth_failure_window"`
	// LogSecurityEvents enables detailed security logging
	LogSecurityEvents bool `yaml:"log_security_events" json:"log_security_events"`
}

type SecurityError struct {
	Type    string
	Message string
}

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

type Sender interface {
	// Send sends an email message
	Send(ctx context.Context, message *Message) error
	// SendAsync sends an email message asynchronously using the queue
	SendAsync(ctx context.Context, message *Message) error
}

type Server interface {
	// Start starts the SMTP server
	Start(ctx context.Context) error
	// Stop stops the SMTP server
	Stop(ctx context.Context) error
	// AddHandler adds a notification handler
	AddHandler(handler NotificationHandler)
	// IsRunning returns true if the server is running
	IsRunning() bool
}

type ServerConfig struct {
	// Enabled indicates if the SMTP server should be started
	Enabled bool `yaml:"enabled" json:"enabled"`
	// Host to bind the server to
	Host string `yaml:"host" json:"host"`
	// Port to bind the server to
	Port int `yaml:"port" json:"port"`
	// Domain name for the server
	Domain string `yaml:"domain" json:"domain"`
	// Authentication required for incoming messages
	Auth bool `yaml:"auth" json:"auth"`
	// Username for server authentication
	Username string `yaml:"username" json:"username"`
	// Password for server authentication
	Password string `yaml:"password" json:"password"`
	// TLS encryption enabled
	TLS bool `yaml:"tls" json:"tls"`
	// Certificate file path for TLS
	CertFile string `yaml:"cert_file" json:"cert_file"`
	// Key file path for TLS
	KeyFile string `yaml:"key_file" json:"key_file"`
	// ReadTimeout for server connections
	ReadTimeout time.Duration `yaml:"read_timeout" json:"read_timeout"`
	// WriteTimeout for server connections
	WriteTimeout time.Duration `yaml:"write_timeout" json:"write_timeout"`
	// MaxMessageBytes is the maximum size of a message
	MaxMessageBytes int64 `yaml:"max_message_bytes" json:"max_message_bytes"`
	// MaxRecipients is the maximum number of recipients per message
	MaxRecipients int `yaml:"max_recipients" json:"max_recipients"`
	// AllowInsecureAuth allows authentication over non-TLS connections
	AllowInsecureAuth bool `yaml:"allow_insecure_auth" json:"allow_insecure_auth"`
	// MaxConcurrentHandlers limits the number of concurrent notification handlers
	MaxConcurrentHandlers int `yaml:"max_concurrent_handlers" json:"max_concurrent_handlers"`
	// Security holds the security configuration for the SMTP server
	Security SecurityConfig `yaml:"security" json:"security"`
}

type Session interface {
	AuthPlain(username, password string) error
	Mail(from string, opts *Options) error
	Rcpt(to string, opts *RcptOptions) error
	Data(r io.Reader) error
	Reset()
	Logout() error
}

type Stats struct {
	// SentCount is the number of emails sent
	SentCount int64 `json:"sent_count"`

	// FailedCount is the number of emails that failed to send
	FailedCount int64 `json:"failed_count"`

	// QueuedCount is the number of emails currently queued
	QueuedCount int64 `json:"queued_count"`

	// ReceivedCount is the number of emails received by the server
	ReceivedCount int64 `json:"received_count"`

	// LastSent is the timestamp of the last sent email
	LastSent *time.Time `json:"last_sent,omitempty"`

	// LastReceived is the timestamp of the last received email
	LastReceived *time.Time `json:"last_received,omitempty"`
}

type TemplateConfig struct {
	// Enabled indicates if template processing is enabled
	Enabled bool `yaml:"enabled" json:"enabled"`
	// DefaultTemplate is the name of the default template
	DefaultTemplate string `yaml:"default_template" json:"default_template"`
	// AutoReload indicates if templates should be reloaded on change
	AutoReload bool `yaml:"auto_reload" json:"auto_reload"`
	// FileSystem for loading templates (internal use - not serializable)
	FileSystem fs.FS `yaml:"-" json:"-"`
	// TemplatesPath is the path to custom email templates (used with WithFileServer)
	TemplatesPath string `yaml:"templates_path" json:"templates_path"`
	// WithDefaultFuncs indicates if default template functions should be included
	WithDefaultFuncs bool `yaml:"-" json:"-"`
	// GlobalFuncs defines additional global template functions
	GlobalFuncs template.FuncMap `yaml:"-" json:"-"`
}

type TemplateData struct {
	// Subject is the email subject
	Subject string `json:"subject"`

	// Data is the custom data for the template
	Data interface{} `json:"data"`

	// Metadata contains additional metadata
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type TemplateManager struct {
	Error error
	// contains filtered or unexported fields
}