filevalidator

type ArchiveValidator struct {
	MaxCompressionRatio float64
	MaxFiles            int
	MaxDepth            int
	MaxUncompressedSize int64
	MaxNestedArchives   int
	ArchiveExtensions   []string
}

type Constraints struct {
	// MaxFileSize is the maximum allowed file size in bytes
	// Use the provided constants for readable configuration, e.g., 10 * MB for 10 megabytes
	MaxFileSize int64

	// MinFileSize is the minimum allowed file size in bytes
	// Use the provided constants for readable configuration, e.g., 1 * KB for 1 kilobyte
	MinFileSize int64

	// AcceptedTypes is a list of allowed MIME types (e.g., "image/jpeg", "application/pdf")
	// Special media type groups like "image/*" are also supported
	AcceptedTypes []string

	// AllowedExts is a list of allowed file extensions including the dot (e.g., ".jpg", ".pdf")
	// If empty, all extensions are allowed unless blocked by BlockedExts
	AllowedExts []string

	// BlockedExts is a list of blocked file extensions including the dot (e.g., ".exe", ".php")
	// These extensions will be blocked regardless of AllowedExts configuration
	BlockedExts []string

	// MaxNameLength is the maximum allowed length for filenames (including extension)
	// If set to 0, no length limit will be enforced
	MaxNameLength int

	// FileNameRegex is an optional regular expression pattern for validating filenames
	// If nil, no pattern matching will be performed
	FileNameRegex *regexp.Regexp

	// DangerousChars is a list of characters considered dangerous in filenames
	DangerousChars []string

	// RequireExtension enforces that files must have an extension
	RequireExtension bool

	// StrictMIMETypeValidation requires that both the MIME type and extension match
	StrictMIMETypeValidation bool

	// ContentValidationEnabled enables deep content validation
	ContentValidationEnabled bool

	// RequireContentValidation makes content validation mandatory
	RequireContentValidation bool

	// ContentValidatorRegistry holds content validators for different file types
	ContentValidatorRegistry *ContentValidatorRegistry
}

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

type ContentValidator interface {
	// ValidateContent validates the content of a file
	ValidateContent(reader io.Reader, size int64) error
	// SupportedMIMETypes returns the MIME types this validator can handle
	SupportedMIMETypes() []string
}

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

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

type ImageValidator struct {
	MaxWidth       int
	MaxHeight      int
	MaxPixels      int
	MinWidth       int
	MinHeight      int
	ValidatePixels bool
	AllowSVG       bool
	MaxSVGSize     int64
}

type MediaTypeGroup string

type PDFValidator struct {
	AllowJavaScript    bool
	AllowEmbeddedFiles bool
	AllowForms         bool
	AllowActions       bool
	MaxSize            int64
	ValidateStructure  bool
}

type ValidationError struct {
	Type    ValidationErrorType
	Message string
}

type ValidationErrorType string

type Validator interface {
	// Validate validates a file against the validator's constraints
	Validate(file *multipart.FileHeader) error

	// ValidateWithContext validates a file with context for potential cancellation
	ValidateWithContext(ctx context.Context, file *multipart.FileHeader) error

	// ValidateReader validates a file from an io.Reader with a filename
	ValidateReader(reader io.Reader, filename string, size int64) error

	// ValidateBytes validates a file from a byte slice with a filename
	ValidateBytes(content []byte, filename string) error

	// GetConstraints returns the current validation constraints
	GetConstraints() Constraints
}