chore(deps): update module github.com/oapi-codegen/oapi-codegen/v2 to v2.6.0

2026-04-09 11:10:23 +00:00
49 changed files with 1788 additions and 1888 deletions
--- a/.gitignore
+++ b/.gitignore
@ -26,5 +26,5 @@ logs/
 *.sqlite3

 # OpenAPI generated files
-internal/api/server.gen.go
-internal/model/types.gen.go
+internal/api/models.gen.go
+internal/api/server.gen.go
--- a/api/config-models.yaml
+++ b/api/config-models.yaml
@ -1,9 +1,5 @@
-package: model
+package: api
 generate:
  models: true
-  embedded-spec: true
-output: internal/model/types.gen.go
-output-options:
-  skip-prune: true
-import-mapping:
-  ./schemas.yaml: "-"
+  embedded-spec: false
+output: internal/api/models.gen.go
--- a/api/config-server.yaml
+++ b/api/config-server.yaml
@ -1,8 +1,5 @@
 package: api
 generate:
  gin-server: true
-  models: true
  embedded-spec: true
 output: internal/api/server.gen.go
-import-mapping:
-  ./schemas.yaml: git.happydns.org/happyDeliver/internal/model
--- a/api/openapi.yaml
+++ b/api/openapi.yaml
--- a/api/schemas.yaml
+++ b/api/schemas.yaml
--- a/generate.go
+++ b/generate.go
@ -21,5 +21,5 @@

 package main

-//go:generate go tool oapi-codegen -config api/config-models.yaml api/schemas.yaml
+//go:generate go tool oapi-codegen -config api/config-models.yaml api/openapi.yaml
 //go:generate go tool oapi-codegen -config api/config-server.yaml api/openapi.yaml
--- a/go.mod
+++ b/go.mod
@ -5,7 +5,6 @@ go 1.25.0
 require (
 	github.com/JGLTechnologies/gin-rate-limit v1.5.6
 	github.com/emersion/go-smtp v0.24.0
-	github.com/getkin/kin-openapi v0.133.0
 	github.com/gin-gonic/gin v1.12.0
 	github.com/google/uuid v1.6.0
 	github.com/oapi-codegen/runtime v1.3.0
@ -16,7 +15,6 @@ require (
 )

 require (
-	github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect
 	github.com/bytedance/gopkg v0.1.3 // indirect
 	github.com/bytedance/sonic v1.15.0 // indirect
 	github.com/bytedance/sonic/loader v0.5.0 // indirect
@ -26,6 +24,7 @@ require (
 	github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect
 	github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.12 // indirect
+	github.com/getkin/kin-openapi v0.133.0 // indirect
 	github.com/gin-contrib/sse v1.1.0 // indirect
 	github.com/go-openapi/jsonpointer v0.22.4 // indirect
 	github.com/go-openapi/swag/jsonname v0.25.4 // indirect
--- a/go.sum
+++ b/go.sum
@ -1,9 +1,5 @@
 github.com/JGLTechnologies/gin-rate-limit v1.5.6 h1:BrL2wXrF7SSqmB88YTGFVKMGVcjURMUeKqwQrlmzweI=
 github.com/JGLTechnologies/gin-rate-limit v1.5.6/go.mod h1:fwUuBegxLKm8+/4ST0zDFssRFTFaVZ7bH3ApK7iNZww=
-github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk=
-github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ=
-github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk=
-github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
@ -102,7 +98,6 @@ github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8Hm
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@ -130,8 +125,8 @@ github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwd
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/oapi-codegen/oapi-codegen/v2 v2.5.1 h1:5vHNY1uuPBRBWqB2Dp0G7YB03phxLQZupZTIZaeorjc=
-github.com/oapi-codegen/oapi-codegen/v2 v2.5.1/go.mod h1:ro0npU1BWkcGpCgGD9QwPp44l5OIZ94tB3eabnT7DjQ=
+github.com/oapi-codegen/oapi-codegen/v2 v2.6.0 h1:4i+F2cvwBFZeplxCssNdLy3MhNzUD87mI3HnayHZkAU=
+github.com/oapi-codegen/oapi-codegen/v2 v2.6.0/go.mod h1:eWHeJSohQJIINJZzzQriVynfGsnlQVh0UkN2UYYcw4Q=
 github.com/oapi-codegen/runtime v1.3.0 h1:vyK1zc0gDWWXgk2xoQa4+X4RNNc5SL2RbTpJS/4vMYA=
 github.com/oapi-codegen/runtime v1.3.0/go.mod h1:kOdeacKy7t40Rclb1je37ZLFboFxh+YLy0zaPCMibPY=
 github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 h1:G7ERwszslrBzRxj//JalHPu/3yz+De2J+4aLtSRlHiY=
@ -170,7 +165,6 @@ github.com/speakeasy-api/jsonpath v0.6.0 h1:IhtFOV9EbXplhyRqsVhHoBmmYjblIRh5D1/g
 github.com/speakeasy-api/jsonpath v0.6.0/go.mod h1:ymb2iSkyOycmzKwbEAYPJV/yi2rSmvBCLZJcyD+VVWw=
 github.com/speakeasy-api/openapi-overlay v0.10.2 h1:VOdQ03eGKeiHnpb1boZCGm7x8Haj6gST0P3SGTX95GU=
 github.com/speakeasy-api/openapi-overlay v0.10.2/go.mod h1:n0iOU7AqKpNFfEt6tq7qYITC4f0yzVVdFw0S7hukemg=
-github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
--- a/internal/api/handlers.go
+++ b/internal/api/handlers.go
@ -31,7 +31,6 @@ import (
 	openapi_types "github.com/oapi-codegen/runtime/types"

 	"git.happydns.org/happyDeliver/internal/config"
-	"git.happydns.org/happyDeliver/internal/model"
 	"git.happydns.org/happyDeliver/internal/storage"
 	"git.happydns.org/happyDeliver/internal/utils"
 	"git.happydns.org/happyDeliver/internal/version"
@ -41,8 +40,8 @@ import (
 // This interface breaks the circular dependency with pkg/analyzer
 type EmailAnalyzer interface {
 	AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) (reportJSON []byte, err error)
-	AnalyzeDomain(domain string) (dnsResults *model.DNSResults, score int, grade string)
-	CheckBlacklistIP(ip string) (checks []model.BlacklistCheck, whitelists []model.BlacklistCheck, listedCount int, score int, grade string, err error)
+	AnalyzeDomain(domain string) (dnsResults *DNSResults, score int, grade string)
+	CheckBlacklistIP(ip string) (checks []BlacklistCheck, whitelists []BlacklistCheck, listedCount int, score int, grade string, err error)
 }

 // APIHandler implements the ServerInterface for handling API requests
@ -80,11 +79,11 @@ func (h *APIHandler) CreateTest(c *gin.Context) {
 	)

 	// Return response
-	c.JSON(http.StatusCreated, model.TestResponse{
+	c.JSON(http.StatusCreated, TestResponse{
 		Id:      base32ID,
 		Email:   openapi_types.Email(email),
-		Status:  model.TestResponseStatusPending,
-		Message: utils.PtrTo("Send your test email to the given address"),
+		Status:  TestResponseStatusPending,
+		Message: stringPtr("Send your test email to the given address"),
 	})
 }

@ -94,10 +93,10 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
 	// Convert base32 ID to UUID
 	testUUID, err := utils.Base32ToUUID(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_id",
 			Message: "Invalid test ID format",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -105,20 +104,20 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
 	// Check if a report exists for this test ID
 	reportExists, err := h.storage.ReportExists(testUUID)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to check test status",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}

 	// Determine status based on report existence
-	var apiStatus model.TestStatus
+	var apiStatus TestStatus
 	if reportExists {
-		apiStatus = model.TestStatusAnalyzed
+		apiStatus = TestStatusAnalyzed
 	} else {
-		apiStatus = model.TestStatusPending
+		apiStatus = TestStatusPending
 	}

 	// Generate test email address using Base32-encoded UUID
@ -128,7 +127,7 @@ func (h *APIHandler) GetTest(c *gin.Context, id string) {
 		h.config.Email.Domain,
 	)

-	c.JSON(http.StatusOK, model.Test{
+	c.JSON(http.StatusOK, Test{
 		Id:     id,
 		Email:  openapi_types.Email(email),
 		Status: apiStatus,
@ -141,10 +140,10 @@ func (h *APIHandler) GetReport(c *gin.Context, id string) {
 	// Convert base32 ID to UUID
 	testUUID, err := utils.Base32ToUUID(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_id",
 			Message: "Invalid test ID format",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -152,16 +151,16 @@ func (h *APIHandler) GetReport(c *gin.Context, id string) {
 	reportJSON, _, err := h.storage.GetReport(testUUID)
 	if err != nil {
 		if err == storage.ErrNotFound {
-			c.JSON(http.StatusNotFound, model.Error{
+			c.JSON(http.StatusNotFound, Error{
 				Error:   "not_found",
 				Message: "Report not found",
 			})
 			return
 		}
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to retrieve report",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -176,10 +175,10 @@ func (h *APIHandler) GetRawEmail(c *gin.Context, id string) {
 	// Convert base32 ID to UUID
 	testUUID, err := utils.Base32ToUUID(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_id",
 			Message: "Invalid test ID format",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -187,16 +186,16 @@ func (h *APIHandler) GetRawEmail(c *gin.Context, id string) {
 	_, rawEmail, err := h.storage.GetReport(testUUID)
 	if err != nil {
 		if err == storage.ErrNotFound {
-			c.JSON(http.StatusNotFound, model.Error{
+			c.JSON(http.StatusNotFound, Error{
 				Error:   "not_found",
 				Message: "Email not found",
 			})
 			return
 		}
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to retrieve raw email",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -210,10 +209,10 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
 	// Convert base32 ID to UUID
 	testUUID, err := utils.Base32ToUUID(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_id",
 			Message: "Invalid test ID format",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -222,16 +221,16 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
 	_, rawEmail, err := h.storage.GetReport(testUUID)
 	if err != nil {
 		if err == storage.ErrNotFound {
-			c.JSON(http.StatusNotFound, model.Error{
+			c.JSON(http.StatusNotFound, Error{
 				Error:   "not_found",
 				Message: "Email not found",
 			})
 			return
 		}
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to retrieve email",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -239,20 +238,20 @@ func (h *APIHandler) ReanalyzeReport(c *gin.Context, id string) {
 	// Re-analyze the email using the current analyzer
 	reportJSON, err := h.analyzer.AnalyzeEmailBytes(rawEmail, testUUID)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "analysis_error",
 			Message: "Failed to re-analyze email",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}

 	// Update the report in storage
 	if err := h.storage.UpdateReport(testUUID, reportJSON); err != nil {
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to update report",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -268,24 +267,24 @@ func (h *APIHandler) GetStatus(c *gin.Context) {
 	uptime := int(time.Since(h.startTime).Seconds())

 	// Check database connectivity by trying to check if a report exists
-	dbStatus := model.StatusComponentsDatabaseUp
+	dbStatus := StatusComponentsDatabaseUp
 	if _, err := h.storage.ReportExists(uuid.New()); err != nil {
-		dbStatus = model.StatusComponentsDatabaseDown
+		dbStatus = StatusComponentsDatabaseDown
 	}

 	// Determine overall status
-	overallStatus := model.Healthy
-	if dbStatus == model.StatusComponentsDatabaseDown {
-		overallStatus = model.Unhealthy
+	overallStatus := Healthy
+	if dbStatus == StatusComponentsDatabaseDown {
+		overallStatus = Unhealthy
 	}

-	mtaStatus := model.StatusComponentsMtaUp
-	c.JSON(http.StatusOK, model.Status{
+	mtaStatus := StatusComponentsMtaUp
+	c.JSON(http.StatusOK, Status{
 		Status:  overallStatus,
 		Version: version.Version,
 		Components: &struct {
-			Database *model.StatusComponentsDatabase `json:"database,omitempty"`
-			Mta      *model.StatusComponentsMta      `json:"mta,omitempty"`
+			Database *StatusComponentsDatabase `json:"database,omitempty"`
+			Mta      *StatusComponentsMta      `json:"mta,omitempty"`
 		}{
 			Database: &dbStatus,
 			Mta:      &mtaStatus,
@ -297,14 +296,14 @@ func (h *APIHandler) GetStatus(c *gin.Context) {
 // TestDomain performs synchronous domain analysis
 // (POST /domain)
 func (h *APIHandler) TestDomain(c *gin.Context) {
-	var request model.DomainTestRequest
+	var request DomainTestRequest

 	// Bind and validate request
 	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_request",
 			Message: "Invalid request body",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -313,28 +312,28 @@ func (h *APIHandler) TestDomain(c *gin.Context) {
 	dnsResults, score, grade := h.analyzer.AnalyzeDomain(request.Domain)

 	// Convert grade string to DomainTestResponseGrade enum
-	var responseGrade model.DomainTestResponseGrade
+	var responseGrade DomainTestResponseGrade
 	switch grade {
 	case "A+":
-		responseGrade = model.DomainTestResponseGradeA
+		responseGrade = DomainTestResponseGradeA
 	case "A":
-		responseGrade = model.DomainTestResponseGradeA1
+		responseGrade = DomainTestResponseGradeA1
 	case "B":
-		responseGrade = model.DomainTestResponseGradeB
+		responseGrade = DomainTestResponseGradeB
 	case "C":
-		responseGrade = model.DomainTestResponseGradeC
+		responseGrade = DomainTestResponseGradeC
 	case "D":
-		responseGrade = model.DomainTestResponseGradeD
+		responseGrade = DomainTestResponseGradeD
 	case "E":
-		responseGrade = model.DomainTestResponseGradeE
+		responseGrade = DomainTestResponseGradeE
 	case "F":
-		responseGrade = model.DomainTestResponseGradeF
+		responseGrade = DomainTestResponseGradeF
 	default:
-		responseGrade = model.DomainTestResponseGradeF
+		responseGrade = DomainTestResponseGradeF
 	}

 	// Build response
-	response := model.DomainTestResponse{
+	response := DomainTestResponse{
 		Domain:     request.Domain,
 		Score:      score,
 		Grade:      responseGrade,
@ -347,14 +346,14 @@ func (h *APIHandler) TestDomain(c *gin.Context) {
 // CheckBlacklist checks an IP address against DNS blacklists
 // (POST /blacklist)
 func (h *APIHandler) CheckBlacklist(c *gin.Context) {
-	var request model.BlacklistCheckRequest
+	var request BlacklistCheckRequest

 	// Bind and validate request
 	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_request",
 			Message: "Invalid request body",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}
@ -362,22 +361,22 @@ func (h *APIHandler) CheckBlacklist(c *gin.Context) {
 	// Perform blacklist check using analyzer
 	checks, whitelists, listedCount, score, grade, err := h.analyzer.CheckBlacklistIP(request.Ip)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, model.Error{
+		c.JSON(http.StatusBadRequest, Error{
 			Error:   "invalid_ip",
 			Message: "Invalid IP address",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}

 	// Build response
-	response := model.BlacklistCheckResponse{
+	response := BlacklistCheckResponse{
 		Ip:          request.Ip,
 		Blacklists:  checks,
 		Whitelists:  &whitelists,
 		ListedCount: listedCount,
 		Score:       score,
-		Grade:       model.BlacklistCheckResponseGrade(grade),
+		Grade:       BlacklistCheckResponseGrade(grade),
 	}

 	c.JSON(http.StatusOK, response)
@ -387,7 +386,7 @@ func (h *APIHandler) CheckBlacklist(c *gin.Context) {
 // (GET /tests)
 func (h *APIHandler) ListTests(c *gin.Context, params ListTestsParams) {
 	if h.config.DisableTestList {
-		c.JSON(http.StatusForbidden, model.Error{
+		c.JSON(http.StatusForbidden, Error{
 			Error:   "feature_disabled",
 			Message: "Test listing is disabled on this instance",
 		})
@ -406,17 +405,51 @@ func (h *APIHandler) ListTests(c *gin.Context, params ListTestsParams) {
 		}
 	}

-	tests, total, err := h.storage.ListReportSummaries(offset, limit)
+	summaries, total, err := h.storage.ListReportSummaries(offset, limit)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, model.Error{
+		c.JSON(http.StatusInternalServerError, Error{
 			Error:   "internal_error",
 			Message: "Failed to list tests",
-			Details: utils.PtrTo(err.Error()),
+			Details: stringPtr(err.Error()),
 		})
 		return
 	}

-	c.JSON(http.StatusOK, model.TestListResponse{
+	tests := make([]TestSummary, 0, len(summaries))
+	for _, s := range summaries {
+		base32ID := utils.UUIDToBase32(s.TestID)
+
+		var grade TestSummaryGrade
+		switch s.Grade {
+		case "A+":
+			grade = TestSummaryGradeA
+		case "A":
+			grade = TestSummaryGradeA1
+		case "B":
+			grade = TestSummaryGradeB
+		case "C":
+			grade = TestSummaryGradeC
+		case "D":
+			grade = TestSummaryGradeD
+		case "E":
+			grade = TestSummaryGradeE
+		default:
+			grade = TestSummaryGradeF
+		}
+
+		summary := TestSummary{
+			TestId:    base32ID,
+			Score:     s.Score,
+			Grade:     grade,
+			CreatedAt: s.CreatedAt,
+		}
+		if s.FromDomain != "" {
+			summary.FromDomain = stringPtr(s.FromDomain)
+		}
+		tests = append(tests, summary)
+	}
+
+	c.JSON(http.StatusOK, TestListResponse{
 		Tests:  tests,
 		Total:  int(total),
 		Offset: offset,
--- a/internal/api/helpers.go
+++ b/internal/api/helpers.go
@ -1,5 +1,5 @@
 // This file is part of the happyDeliver (R) project.
-// Copyright (c) 2026 happyDomain
+// Copyright (c) 2025 happyDomain
 // Authors: Pierre-Olivier Mercier, et al.
 //
 // This program is offered under a commercial and under the AGPL license.
@ -19,7 +19,11 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

-package utils
+package api
+
+func stringPtr(s string) *string {
+	return &s
+}

 // PtrTo returns a pointer to the provided value
 func PtrTo[T any](v T) *T {
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@ -30,9 +30,6 @@ import (
 	"gorm.io/driver/postgres"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
-
-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
 )

 var (
@ -48,12 +45,21 @@ type Storage interface {
 	ReportExists(testID uuid.UUID) (bool, error)
 	UpdateReport(testID uuid.UUID, reportJSON []byte) error
 	DeleteOldReports(olderThan time.Time) (int64, error)
-	ListReportSummaries(offset, limit int) ([]model.TestSummary, int64, error)
+	ListReportSummaries(offset, limit int) ([]ReportSummary, int64, error)

 	// Close closes the database connection
 	Close() error
 }

+// ReportSummary is a lightweight projection of Report for listing
+type ReportSummary struct {
+	TestID     uuid.UUID
+	Score      int
+	Grade      string
+	FromDomain string
+	CreatedAt  time.Time
+}
+
 // DBStorage implements Storage using GORM
 type DBStorage struct {
 	db *gorm.DB
@ -143,24 +149,15 @@ func (s *DBStorage) DeleteOldReports(olderThan time.Time) (int64, error) {
 	return result.RowsAffected, nil
 }

-// reportSummaryRow is used internally to scan SQL results before converting to model.TestSummary
-type reportSummaryRow struct {
-	TestID     uuid.UUID
-	Score      int
-	Grade      string
-	FromDomain string
-	CreatedAt  time.Time
-}
-
 // ListReportSummaries returns a paginated list of lightweight report summaries
-func (s *DBStorage) ListReportSummaries(offset, limit int) ([]model.TestSummary, int64, error) {
+func (s *DBStorage) ListReportSummaries(offset, limit int) ([]ReportSummary, int64, error) {
 	var total int64
 	if err := s.db.Model(&Report{}).Count(&total).Error; err != nil {
 		return nil, 0, fmt.Errorf("failed to count reports: %w", err)
 	}

 	if total == 0 {
-		return []model.TestSummary{}, 0, nil
+		return []ReportSummary{}, 0, nil
 	}

 	var selectExpr string
@ -171,41 +168,25 @@ func (s *DBStorage) ListReportSummaries(offset, limit int) ([]model.TestSummary,
 			`convert_from(report_json, 'UTF8')::jsonb->>'grade' as grade, ` +
 			`convert_from(report_json, 'UTF8')::jsonb->'dns_results'->>'from_domain' as from_domain, ` +
 			`created_at`
-	case "sqlite":
+	default: // sqlite
 		selectExpr = `test_id, ` +
 			`json_extract(report_json, '$.score') as score, ` +
 			`json_extract(report_json, '$.grade') as grade, ` +
 			`json_extract(report_json, '$.dns_results.from_domain') as from_domain, ` +
 			`created_at`
-	default:
-		return nil, 0, fmt.Errorf("history tests list not implemented in this database dialect")
 	}

-	var rows []reportSummaryRow
+	var summaries []ReportSummary
 	err := s.db.Model(&Report{}).
 		Select(selectExpr).
 		Order("created_at DESC").
 		Offset(offset).
 		Limit(limit).
-		Scan(&rows).Error
+		Scan(&summaries).Error
 	if err != nil {
 		return nil, 0, fmt.Errorf("failed to list report summaries: %w", err)
 	}

-	summaries := make([]model.TestSummary, 0, len(rows))
-	for _, r := range rows {
-		s := model.TestSummary{
-			TestId:    utils.UUIDToBase32(r.TestID),
-			Score:     r.Score,
-			Grade:     model.TestSummaryGrade(r.Grade),
-			CreatedAt: r.CreatedAt,
-		}
-		if r.FromDomain != "" {
-			s.FromDomain = utils.PtrTo(r.FromDomain)
-		}
-		summaries = append(summaries, s)
-	}
-
 	return summaries, total, nil
 }

--- a/pkg/analyzer/analyzer.go
+++ b/pkg/analyzer/analyzer.go
@ -28,7 +28,7 @@ import (

 	"github.com/google/uuid"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 	"git.happydns.org/happyDeliver/internal/config"
 )

@ -59,7 +59,7 @@ func NewEmailAnalyzer(cfg *config.Config) *EmailAnalyzer {
 type AnalysisResult struct {
 	Email   *EmailMessage
 	Results *AnalysisResults
-	Report  *model.Report
+	Report  *api.Report
 }

 // AnalyzeEmailBytes performs complete email analysis from raw bytes
@ -113,7 +113,7 @@ func (a *APIAdapter) AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) ([]byt
 }

 // AnalyzeDomain performs DNS analysis for a domain and returns the results
-func (a *APIAdapter) AnalyzeDomain(domain string) (*model.DNSResults, int, string) {
+func (a *APIAdapter) AnalyzeDomain(domain string) (*api.DNSResults, int, string) {
 	// Perform DNS analysis
 	dnsResults := a.analyzer.generator.dnsAnalyzer.AnalyzeDomainOnly(domain)

@ -124,7 +124,7 @@ func (a *APIAdapter) AnalyzeDomain(domain string) (*model.DNSResults, int, strin
 }

 // CheckBlacklistIP checks a single IP address against DNS blacklists and whitelists
-func (a *APIAdapter) CheckBlacklistIP(ip string) ([]model.BlacklistCheck, []model.BlacklistCheck, int, int, string, error) {
+func (a *APIAdapter) CheckBlacklistIP(ip string) ([]api.BlacklistCheck, []api.BlacklistCheck, int, int, string, error) {
 	// Check the IP against all configured RBLs
 	checks, listedCount, err := a.analyzer.generator.rblChecker.CheckIP(ip)
 	if err != nil {
@ -134,7 +134,7 @@ func (a *APIAdapter) CheckBlacklistIP(ip string) ([]model.BlacklistCheck, []mode
 	// Calculate score using the existing function
 	// Create a minimal RBLResults structure for scoring
 	results := &DNSListResults{
-		Checks:      map[string][]model.BlacklistCheck{ip: checks},
+		Checks:      map[string][]api.BlacklistCheck{ip: checks},
 		IPsChecked:  []string{ip},
 		ListedCount: listedCount,
 	}
--- a/pkg/analyzer/authentication.go
+++ b/pkg/analyzer/authentication.go
@ -24,7 +24,7 @@ package analyzer
 import (
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // AuthenticationAnalyzer analyzes email authentication results
@ -38,8 +38,8 @@ func NewAuthenticationAnalyzer(receiverHostname string) *AuthenticationAnalyzer
 }

 // AnalyzeAuthentication extracts and analyzes authentication results from email headers
-func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *model.AuthenticationResults {
-	results := &model.AuthenticationResults{}
+func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *api.AuthenticationResults {
+	results := &api.AuthenticationResults{}

 	// Parse Authentication-Results headers
 	authHeaders := email.GetAuthenticationResults(a.receiverHostname)
@ -65,7 +65,7 @@ func (a *AuthenticationAnalyzer) AnalyzeAuthentication(email *EmailMessage) *mod

 // parseAuthenticationResultsHeader parses an Authentication-Results header
 // Format: example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com
-func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string, results *model.AuthenticationResults) {
+func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string, results *api.AuthenticationResults) {
 	// Split by semicolon to get individual results
 	parts := strings.Split(header, ";")
 	if len(parts) < 2 {
@ -91,7 +91,7 @@ func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string,
 			dkimResult := a.parseDKIMResult(part)
 			if dkimResult != nil {
 				if results.Dkim == nil {
-					dkimList := []model.AuthResult{*dkimResult}
+					dkimList := []api.AuthResult{*dkimResult}
 					results.Dkim = &dkimList
 				} else {
 					*results.Dkim = append(*results.Dkim, *dkimResult)
@ -145,7 +145,7 @@ func (a *AuthenticationAnalyzer) parseAuthenticationResultsHeader(header string,

 // CalculateAuthenticationScore calculates the authentication score from auth results
 // Returns a score from 0-100 where higher is better
-func (a *AuthenticationAnalyzer) CalculateAuthenticationScore(results *model.AuthenticationResults) (int, string) {
+func (a *AuthenticationAnalyzer) CalculateAuthenticationScore(results *api.AuthenticationResults) (int, string) {
 	if results == nil {
 		return 0, ""
 	}
--- a/pkg/analyzer/authentication_arc.go
+++ b/pkg/analyzer/authentication_arc.go
@ -27,8 +27,7 @@ import (
 	"slices"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // textprotoCanonical converts a header name to canonical form
@ -53,24 +52,24 @@ func pluralize(count int) string {

 // parseARCResult parses ARC result from Authentication-Results
 // Example: arc=pass
-func (a *AuthenticationAnalyzer) parseARCResult(part string) *model.ARCResult {
-	result := &model.ARCResult{}
+func (a *AuthenticationAnalyzer) parseARCResult(part string) *api.ARCResult {
+	result := &api.ARCResult{}

 	// Extract result (pass, fail, none)
 	re := regexp.MustCompile(`arc=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.ARCResultResult(resultStr)
+		result.Result = api.ARCResultResult(resultStr)
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "arc="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "arc="))

 	return result
 }

 // parseARCHeaders parses ARC headers from email message
 // ARC consists of three headers per hop: ARC-Authentication-Results, ARC-Message-Signature, ARC-Seal
-func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *model.ARCResult {
+func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *api.ARCResult {
 	// Get all ARC-related headers
 	arcAuthResults := email.Header[textprotoCanonical("ARC-Authentication-Results")]
 	arcMessageSig := email.Header[textprotoCanonical("ARC-Message-Signature")]
@ -81,8 +80,8 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *model.ARC
 		return nil
 	}

-	result := &model.ARCResult{
-		Result: model.ARCResultResultNone,
+	result := &api.ARCResult{
+		Result: api.ARCResultResultNone,
 	}

 	// Count the ARC chain length (number of sets)
@ -95,15 +94,15 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *model.ARC

 	// Determine overall result
 	if chainLength == 0 {
-		result.Result = model.ARCResultResultNone
+		result.Result = api.ARCResultResultNone
 		details := "No ARC chain present"
 		result.Details = &details
 	} else if !chainValid {
-		result.Result = model.ARCResultResultFail
+		result.Result = api.ARCResultResultFail
 		details := fmt.Sprintf("ARC chain validation failed (chain length: %d)", chainLength)
 		result.Details = &details
 	} else {
-		result.Result = model.ARCResultResultPass
+		result.Result = api.ARCResultResultPass
 		details := fmt.Sprintf("ARC chain valid with %d intermediar%s", chainLength, pluralize(chainLength))
 		result.Details = &details
 	}
@ -112,7 +111,7 @@ func (a *AuthenticationAnalyzer) parseARCHeaders(email *EmailMessage) *model.ARC
 }

 // enhanceARCResult enhances an existing ARC result with chain information
-func (a *AuthenticationAnalyzer) enhanceARCResult(email *EmailMessage, arcResult *model.ARCResult) {
+func (a *AuthenticationAnalyzer) enhanceARCResult(email *EmailMessage, arcResult *api.ARCResult) {
 	if arcResult == nil {
 		return
 	}
--- a/pkg/analyzer/authentication_arc_test.go
+++ b/pkg/analyzer/authentication_arc_test.go
@ -24,29 +24,29 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseARCResult(t *testing.T) {
 	tests := []struct {
 		name           string
 		part           string
-		expectedResult model.ARCResultResult
+		expectedResult api.ARCResultResult
 	}{
 		{
 			name:           "ARC pass",
 			part:           "arc=pass",
-			expectedResult: model.ARCResultResultPass,
+			expectedResult: api.ARCResultResultPass,
 		},
 		{
 			name:           "ARC fail",
 			part:           "arc=fail",
-			expectedResult: model.ARCResultResultFail,
+			expectedResult: api.ARCResultResultFail,
 		},
 		{
 			name:           "ARC none",
 			part:           "arc=none",
-			expectedResult: model.ARCResultResultNone,
+			expectedResult: api.ARCResultResultNone,
 		},
 	}

--- a/pkg/analyzer/authentication_bimi.go
+++ b/pkg/analyzer/authentication_bimi.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseBIMIResult parses BIMI result from Authentication-Results
 // Example: bimi=pass header.d=example.com header.selector=default
-func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`bimi=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract domain (header.d or d)
@ -55,17 +54,17 @@ func (a *AuthenticationAnalyzer) parseBIMIResult(part string) *model.AuthResult
 		result.Selector = &selector
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "bimi="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "bimi="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateBIMIScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateBIMIScore(results *api.AuthenticationResults) (score int) {
 	if results.Bimi != nil {
 		switch results.Bimi.Result {
-		case model.AuthResultResultPass:
+		case api.AuthResultResultPass:
 			return 100
-		case model.AuthResultResultDeclined:
+		case api.AuthResultResultDeclined:
 			return 59
 		default: // fail
 			return 0
--- a/pkg/analyzer/authentication_bimi_test.go
+++ b/pkg/analyzer/authentication_bimi_test.go
@ -24,42 +24,42 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseBIMIResult(t *testing.T) {
 	tests := []struct {
 		name             string
 		part             string
-		expectedResult   model.AuthResultResult
+		expectedResult   api.AuthResultResult
 		expectedDomain   string
 		expectedSelector string
 	}{
 		{
 			name:             "BIMI pass with domain and selector",
 			part:             "bimi=pass header.d=example.com header.selector=default",
-			expectedResult:   model.AuthResultResultPass,
+			expectedResult:   api.AuthResultResultPass,
 			expectedDomain:   "example.com",
 			expectedSelector: "default",
 		},
 		{
 			name:             "BIMI fail",
 			part:             "bimi=fail header.d=example.com header.selector=default",
-			expectedResult:   model.AuthResultResultFail,
+			expectedResult:   api.AuthResultResultFail,
 			expectedDomain:   "example.com",
 			expectedSelector: "default",
 		},
 		{
 			name:             "BIMI with short form (d= and selector=)",
 			part:             "bimi=pass d=example.com selector=v1",
-			expectedResult:   model.AuthResultResultPass,
+			expectedResult:   api.AuthResultResultPass,
 			expectedDomain:   "example.com",
 			expectedSelector: "v1",
 		},
 		{
 			name:           "BIMI none",
 			part:           "bimi=none header.d=example.com",
-			expectedResult: model.AuthResultResultNone,
+			expectedResult: api.AuthResultResultNone,
 			expectedDomain: "example.com",
 		},
 	}
--- a/pkg/analyzer/authentication_dkim.go
+++ b/pkg/analyzer/authentication_dkim.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseDKIMResult parses DKIM result from Authentication-Results
 // Example: dkim=pass header.d=example.com header.s=selector1
-func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`dkim=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract domain (header.d or d)
@ -55,18 +54,18 @@ func (a *AuthenticationAnalyzer) parseDKIMResult(part string) *model.AuthResult
 		result.Selector = &selector
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "dkim="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "dkim="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateDKIMScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateDKIMScore(results *api.AuthenticationResults) (score int) {
 	// Expect at least one passing signature
 	if results.Dkim != nil && len(*results.Dkim) > 0 {
 		hasPass := false
 		hasNonPass := false
 		for _, dkim := range *results.Dkim {
-			if dkim.Result == model.AuthResultResultPass {
+			if dkim.Result == api.AuthResultResultPass {
 				hasPass = true
 			} else {
 				hasNonPass = true
--- a/pkg/analyzer/authentication_dkim_test.go
+++ b/pkg/analyzer/authentication_dkim_test.go
@ -24,35 +24,35 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseDKIMResult(t *testing.T) {
 	tests := []struct {
 		name             string
 		part             string
-		expectedResult   model.AuthResultResult
+		expectedResult   api.AuthResultResult
 		expectedDomain   string
 		expectedSelector string
 	}{
 		{
 			name:             "DKIM pass with domain and selector",
 			part:             "dkim=pass header.d=example.com header.s=default",
-			expectedResult:   model.AuthResultResultPass,
+			expectedResult:   api.AuthResultResultPass,
 			expectedDomain:   "example.com",
 			expectedSelector: "default",
 		},
 		{
 			name:             "DKIM fail",
 			part:             "dkim=fail header.d=example.com header.s=selector1",
-			expectedResult:   model.AuthResultResultFail,
+			expectedResult:   api.AuthResultResultFail,
 			expectedDomain:   "example.com",
 			expectedSelector: "selector1",
 		},
 		{
 			name:             "DKIM with short form (d= and s=)",
 			part:             "dkim=pass d=example.com s=default",
-			expectedResult:   model.AuthResultResultPass,
+			expectedResult:   api.AuthResultResultPass,
 			expectedDomain:   "example.com",
 			expectedSelector: "default",
 		},
--- a/pkg/analyzer/authentication_dmarc.go
+++ b/pkg/analyzer/authentication_dmarc.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseDMARCResult parses DMARC result from Authentication-Results
 // Example: dmarc=pass action=none header.from=example.com
-func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`dmarc=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract domain (header.from)
@ -48,17 +47,17 @@ func (a *AuthenticationAnalyzer) parseDMARCResult(part string) *model.AuthResult
 		result.Domain = &domain
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "dmarc="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "dmarc="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateDMARCScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateDMARCScore(results *api.AuthenticationResults) (score int) {
 	if results.Dmarc != nil {
 		switch results.Dmarc.Result {
-		case model.AuthResultResultPass:
+		case api.AuthResultResultPass:
 			return 100
-		case model.AuthResultResultNone:
+		case api.AuthResultResultNone:
 			return 33
 		default: // fail
 			return 0
--- a/pkg/analyzer/authentication_dmarc_test.go
+++ b/pkg/analyzer/authentication_dmarc_test.go
@ -24,26 +24,26 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseDMARCResult(t *testing.T) {
 	tests := []struct {
 		name           string
 		part           string
-		expectedResult model.AuthResultResult
+		expectedResult api.AuthResultResult
 		expectedDomain string
 	}{
 		{
 			name:           "DMARC pass",
 			part:           "dmarc=pass action=none header.from=example.com",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDomain: "example.com",
 		},
 		{
 			name:           "DMARC fail",
 			part:           "dmarc=fail action=quarantine header.from=example.com",
-			expectedResult: model.AuthResultResultFail,
+			expectedResult: api.AuthResultResultFail,
 			expectedDomain: "example.com",
 		},
 	}
--- a/pkg/analyzer/authentication_iprev.go
+++ b/pkg/analyzer/authentication_iprev.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseIPRevResult parses IP reverse lookup result from Authentication-Results
 // Example: iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)
-func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *model.IPRevResult {
-	result := &model.IPRevResult{}
+func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *api.IPRevResult {
+	result := &api.IPRevResult{}

 	// Extract result (pass, fail, temperror, permerror, none)
 	re := regexp.MustCompile(`iprev=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.IPRevResultResult(resultStr)
+		result.Result = api.IPRevResultResult(resultStr)
 	}

 	// Extract IP address (smtp.remote-ip or remote-ip)
@ -55,15 +54,15 @@ func (a *AuthenticationAnalyzer) parseIPRevResult(part string) *model.IPRevResul
 		result.Hostname = &hostname
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "iprev="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "iprev="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateIPRevScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateIPRevScore(results *api.AuthenticationResults) (score int) {
 	if results.Iprev != nil {
 		switch results.Iprev.Result {
-		case model.Pass:
+		case api.Pass:
 			return 100
 		default: // fail, temperror, permerror
 			return 0
--- a/pkg/analyzer/authentication_iprev_test.go
+++ b/pkg/analyzer/authentication_iprev_test.go
@ -24,72 +24,71 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseIPRevResult(t *testing.T) {
 	tests := []struct {
 		name             string
 		part             string
-		expectedResult   model.IPRevResultResult
+		expectedResult   api.IPRevResultResult
 		expectedIP       *string
 		expectedHostname *string
 	}{
 		{
 			name:             "IPRev pass with IP and hostname",
 			part:             "iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)",
-			expectedResult:   model.Pass,
-			expectedIP:       utils.PtrTo("195.110.101.58"),
-			expectedHostname: utils.PtrTo("authsmtp74.register.it"),
+			expectedResult:   api.Pass,
+			expectedIP:       api.PtrTo("195.110.101.58"),
+			expectedHostname: api.PtrTo("authsmtp74.register.it"),
 		},
 		{
 			name:             "IPRev pass without smtp prefix",
 			part:             "iprev=pass remote-ip=192.0.2.1 (mail.example.com)",
-			expectedResult:   model.Pass,
-			expectedIP:       utils.PtrTo("192.0.2.1"),
-			expectedHostname: utils.PtrTo("mail.example.com"),
+			expectedResult:   api.Pass,
+			expectedIP:       api.PtrTo("192.0.2.1"),
+			expectedHostname: api.PtrTo("mail.example.com"),
 		},
 		{
 			name:             "IPRev fail",
 			part:             "iprev=fail smtp.remote-ip=198.51.100.42 (unknown.host.com)",
-			expectedResult:   model.Fail,
-			expectedIP:       utils.PtrTo("198.51.100.42"),
-			expectedHostname: utils.PtrTo("unknown.host.com"),
+			expectedResult:   api.Fail,
+			expectedIP:       api.PtrTo("198.51.100.42"),
+			expectedHostname: api.PtrTo("unknown.host.com"),
 		},
 		{
 			name:             "IPRev temperror",
 			part:             "iprev=temperror smtp.remote-ip=203.0.113.1",
-			expectedResult:   model.Temperror,
-			expectedIP:       utils.PtrTo("203.0.113.1"),
+			expectedResult:   api.Temperror,
+			expectedIP:       api.PtrTo("203.0.113.1"),
 			expectedHostname: nil,
 		},
 		{
 			name:             "IPRev permerror",
 			part:             "iprev=permerror smtp.remote-ip=192.0.2.100",
-			expectedResult:   model.Permerror,
-			expectedIP:       utils.PtrTo("192.0.2.100"),
+			expectedResult:   api.Permerror,
+			expectedIP:       api.PtrTo("192.0.2.100"),
 			expectedHostname: nil,
 		},
 		{
 			name:             "IPRev with IPv6",
 			part:             "iprev=pass smtp.remote-ip=2001:db8::1 (ipv6.example.com)",
-			expectedResult:   model.Pass,
-			expectedIP:       utils.PtrTo("2001:db8::1"),
-			expectedHostname: utils.PtrTo("ipv6.example.com"),
+			expectedResult:   api.Pass,
+			expectedIP:       api.PtrTo("2001:db8::1"),
+			expectedHostname: api.PtrTo("ipv6.example.com"),
 		},
 		{
 			name:             "IPRev with subdomain hostname",
 			part:             "iprev=pass smtp.remote-ip=192.0.2.50 (mail.subdomain.example.com)",
-			expectedResult:   model.Pass,
-			expectedIP:       utils.PtrTo("192.0.2.50"),
-			expectedHostname: utils.PtrTo("mail.subdomain.example.com"),
+			expectedResult:   api.Pass,
+			expectedIP:       api.PtrTo("192.0.2.50"),
+			expectedHostname: api.PtrTo("mail.subdomain.example.com"),
 		},
 		{
 			name:             "IPRev pass without parentheses",
 			part:             "iprev=pass smtp.remote-ip=192.0.2.200",
-			expectedResult:   model.Pass,
-			expectedIP:       utils.PtrTo("192.0.2.200"),
+			expectedResult:   api.Pass,
+			expectedIP:       api.PtrTo("192.0.2.200"),
 			expectedHostname: nil,
 		},
 	}
@ -143,29 +142,29 @@ func TestParseAuthenticationResultsHeader_IPRev(t *testing.T) {
 	tests := []struct {
 		name                string
 		header              string
-		expectedIPRevResult *model.IPRevResultResult
+		expectedIPRevResult *api.IPRevResultResult
 		expectedIP          *string
 		expectedHostname    *string
 	}{
 		{
 			name:                "IPRev pass in Authentication-Results",
 			header:              "mx.google.com; iprev=pass smtp.remote-ip=195.110.101.58 (authsmtp74.register.it)",
-			expectedIPRevResult: utils.PtrTo(model.Pass),
-			expectedIP:          utils.PtrTo("195.110.101.58"),
-			expectedHostname:    utils.PtrTo("authsmtp74.register.it"),
+			expectedIPRevResult: api.PtrTo(api.Pass),
+			expectedIP:          api.PtrTo("195.110.101.58"),
+			expectedHostname:    api.PtrTo("authsmtp74.register.it"),
 		},
 		{
 			name:                "IPRev with other authentication methods",
 			header:              "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; iprev=pass smtp.remote-ip=192.0.2.1 (mail.example.com); dkim=pass header.d=example.com",
-			expectedIPRevResult: utils.PtrTo(model.Pass),
-			expectedIP:          utils.PtrTo("192.0.2.1"),
-			expectedHostname:    utils.PtrTo("mail.example.com"),
+			expectedIPRevResult: api.PtrTo(api.Pass),
+			expectedIP:          api.PtrTo("192.0.2.1"),
+			expectedHostname:    api.PtrTo("mail.example.com"),
 		},
 		{
 			name:                "IPRev fail",
 			header:              "mx.google.com; iprev=fail smtp.remote-ip=198.51.100.42",
-			expectedIPRevResult: utils.PtrTo(model.Fail),
-			expectedIP:          utils.PtrTo("198.51.100.42"),
+			expectedIPRevResult: api.PtrTo(api.Fail),
+			expectedIP:          api.PtrTo("198.51.100.42"),
 			expectedHostname:    nil,
 		},
 		{
@ -176,9 +175,9 @@ func TestParseAuthenticationResultsHeader_IPRev(t *testing.T) {
 		{
 			name:                "Multiple IPRev results - only first is parsed",
 			header:              "mx.google.com; iprev=pass smtp.remote-ip=192.0.2.1 (first.com); iprev=fail smtp.remote-ip=192.0.2.2 (second.com)",
-			expectedIPRevResult: utils.PtrTo(model.Pass),
-			expectedIP:          utils.PtrTo("192.0.2.1"),
-			expectedHostname:    utils.PtrTo("first.com"),
+			expectedIPRevResult: api.PtrTo(api.Pass),
+			expectedIP:          api.PtrTo("192.0.2.1"),
+			expectedHostname:    api.PtrTo("first.com"),
 		},
 	}

@ -186,7 +185,7 @@ func TestParseAuthenticationResultsHeader_IPRev(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			results := &model.AuthenticationResults{}
+			results := &api.AuthenticationResults{}
 			analyzer.parseAuthenticationResultsHeader(tt.header, results)

 			// Check IPRev
--- a/pkg/analyzer/authentication_spf.go
+++ b/pkg/analyzer/authentication_spf.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseSPFResult parses SPF result from Authentication-Results
 // Example: spf=pass smtp.mailfrom=sender@example.com
-func (a *AuthenticationAnalyzer) parseSPFResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseSPFResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`spf=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract domain
@ -52,13 +51,13 @@ func (a *AuthenticationAnalyzer) parseSPFResult(part string) *model.AuthResult {
 		}
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "spf="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "spf="))

 	return result
 }

 // parseLegacySPF attempts to parse SPF from Received-SPF header
-func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *model.AuthResult {
+func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *api.AuthResult {
 	receivedSPF := email.Header.Get("Received-SPF")
 	if receivedSPF == "" {
 		return nil
@ -74,13 +73,13 @@ func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *model.Auth
 		}
 	}

-	result := &model.AuthResult{}
+	result := &api.AuthResult{}

 	// Extract result (first word)
 	parts := strings.Fields(receivedSPF)
 	if len(parts) > 0 {
 		resultStr := strings.ToLower(parts[0])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	result.Details = &receivedSPF
@ -98,14 +97,14 @@ func (a *AuthenticationAnalyzer) parseLegacySPF(email *EmailMessage) *model.Auth
 	return result
 }

-func (a *AuthenticationAnalyzer) calculateSPFScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateSPFScore(results *api.AuthenticationResults) (score int) {
 	if results.Spf != nil {
 		switch results.Spf.Result {
-		case model.AuthResultResultPass:
+		case api.AuthResultResultPass:
 			return 100
-		case model.AuthResultResultNeutral, model.AuthResultResultNone:
+		case api.AuthResultResultNeutral, api.AuthResultResultNone:
 			return 50
-		case model.AuthResultResultSoftfail:
+		case api.AuthResultResultSoftfail:
 			return 17
 		default: // fail, temperror, permerror
 			return 0
--- a/pkg/analyzer/authentication_spf_test.go
+++ b/pkg/analyzer/authentication_spf_test.go
@ -24,39 +24,38 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseSPFResult(t *testing.T) {
 	tests := []struct {
 		name           string
 		part           string
-		expectedResult model.AuthResultResult
+		expectedResult api.AuthResultResult
 		expectedDomain string
 	}{
 		{
 			name:           "SPF pass with domain",
 			part:           "spf=pass smtp.mailfrom=sender@example.com",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDomain: "example.com",
 		},
 		{
 			name:           "SPF fail",
 			part:           "spf=fail smtp.mailfrom=sender@example.com",
-			expectedResult: model.AuthResultResultFail,
+			expectedResult: api.AuthResultResultFail,
 			expectedDomain: "example.com",
 		},
 		{
 			name:           "SPF neutral",
 			part:           "spf=neutral smtp.mailfrom=sender@example.com",
-			expectedResult: model.AuthResultResultNeutral,
+			expectedResult: api.AuthResultResultNeutral,
 			expectedDomain: "example.com",
 		},
 		{
 			name:           "SPF softfail",
 			part:           "spf=softfail smtp.mailfrom=sender@example.com",
-			expectedResult: model.AuthResultResultSoftfail,
+			expectedResult: api.AuthResultResultSoftfail,
 			expectedDomain: "example.com",
 		},
 	}
@ -85,7 +84,7 @@ func TestParseLegacySPF(t *testing.T) {
 	tests := []struct {
 		name           string
 		receivedSPF    string
-		expectedResult model.AuthResultResult
+		expectedResult api.AuthResultResult
 		expectedDomain *string
 		expectNil      bool
 	}{
@ -98,8 +97,8 @@ func TestParseLegacySPF(t *testing.T) {
    envelope-from="user@example.com";
    helo=smtp.example.com;
    client-ip=192.0.2.10`,
-			expectedResult: model.AuthResultResultPass,
-			expectedDomain: utils.PtrTo("example.com"),
+			expectedResult: api.AuthResultResultPass,
+			expectedDomain: api.PtrTo("example.com"),
 		},
 		{
 			name: "SPF fail with sender",
@ -110,43 +109,43 @@ func TestParseLegacySPF(t *testing.T) {
    sender="sender@test.com";
    helo=smtp.test.com;
    client-ip=192.0.2.20`,
-			expectedResult: model.AuthResultResultFail,
-			expectedDomain: utils.PtrTo("test.com"),
+			expectedResult: api.AuthResultResultFail,
+			expectedDomain: api.PtrTo("test.com"),
 		},
 		{
 			name:           "SPF softfail",
 			receivedSPF:    "softfail (example.com: transitioning domain of admin@example.org does not designate 192.0.2.30 as permitted sender) envelope-from=\"admin@example.org\"",
-			expectedResult: model.AuthResultResultSoftfail,
-			expectedDomain: utils.PtrTo("example.org"),
+			expectedResult: api.AuthResultResultSoftfail,
+			expectedDomain: api.PtrTo("example.org"),
 		},
 		{
 			name:           "SPF neutral",
 			receivedSPF:    "neutral (example.com: 192.0.2.40 is neither permitted nor denied by domain of info@domain.net) envelope-from=\"info@domain.net\"",
-			expectedResult: model.AuthResultResultNeutral,
-			expectedDomain: utils.PtrTo("domain.net"),
+			expectedResult: api.AuthResultResultNeutral,
+			expectedDomain: api.PtrTo("domain.net"),
 		},
 		{
 			name:           "SPF none",
 			receivedSPF:    "none (example.com: domain of noreply@company.io has no SPF record) envelope-from=\"noreply@company.io\"",
-			expectedResult: model.AuthResultResultNone,
-			expectedDomain: utils.PtrTo("company.io"),
+			expectedResult: api.AuthResultResultNone,
+			expectedDomain: api.PtrTo("company.io"),
 		},
 		{
 			name:           "SPF temperror",
 			receivedSPF:    "temperror (example.com: error in processing SPF record) envelope-from=\"support@shop.example\"",
-			expectedResult: model.AuthResultResultTemperror,
-			expectedDomain: utils.PtrTo("shop.example"),
+			expectedResult: api.AuthResultResultTemperror,
+			expectedDomain: api.PtrTo("shop.example"),
 		},
 		{
 			name:           "SPF permerror",
 			receivedSPF:    "permerror (example.com: domain of contact@invalid.test has invalid SPF record) envelope-from=\"contact@invalid.test\"",
-			expectedResult: model.AuthResultResultPermerror,
-			expectedDomain: utils.PtrTo("invalid.test"),
+			expectedResult: api.AuthResultResultPermerror,
+			expectedDomain: api.PtrTo("invalid.test"),
 		},
 		{
 			name:           "SPF pass without domain extraction",
 			receivedSPF:    "pass (example.com: 192.0.2.50 is authorized)",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDomain: nil,
 		},
 		{
@ -157,8 +156,8 @@ func TestParseLegacySPF(t *testing.T) {
 		{
 			name:           "SPF with unquoted envelope-from",
 			receivedSPF:    "pass (example.com: sender SPF authorized) envelope-from=postmaster@mail.example.net",
-			expectedResult: model.AuthResultResultPass,
-			expectedDomain: utils.PtrTo("mail.example.net"),
+			expectedResult: api.AuthResultResultPass,
+			expectedDomain: api.PtrTo("mail.example.net"),
 		},
 	}

--- a/pkg/analyzer/authentication_test.go
+++ b/pkg/analyzer/authentication_test.go
@ -24,77 +24,76 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestGetAuthenticationScore(t *testing.T) {
 	tests := []struct {
 		name          string
-		results       *model.AuthenticationResults
+		results       *api.AuthenticationResults
 		expectedScore int
 	}{
 		{
 			name: "Perfect authentication (SPF + DKIM + DMARC)",
-			results: &model.AuthenticationResults{
-				Spf: &model.AuthResult{
-					Result: model.AuthResultResultPass,
+			results: &api.AuthenticationResults{
+				Spf: &api.AuthResult{
+					Result: api.AuthResultResultPass,
 				},
-				Dkim: &[]model.AuthResult{
-					{Result: model.AuthResultResultPass},
+				Dkim: &[]api.AuthResult{
+					{Result: api.AuthResultResultPass},
 				},
-				Dmarc: &model.AuthResult{
-					Result: model.AuthResultResultPass,
+				Dmarc: &api.AuthResult{
+					Result: api.AuthResultResultPass,
 				},
 			},
 			expectedScore: 73, // SPF=25 + DKIM=23 + DMARC=25
 		},
 		{
 			name: "SPF and DKIM only",
-			results: &model.AuthenticationResults{
-				Spf: &model.AuthResult{
-					Result: model.AuthResultResultPass,
+			results: &api.AuthenticationResults{
+				Spf: &api.AuthResult{
+					Result: api.AuthResultResultPass,
 				},
-				Dkim: &[]model.AuthResult{
-					{Result: model.AuthResultResultPass},
+				Dkim: &[]api.AuthResult{
+					{Result: api.AuthResultResultPass},
 				},
 			},
 			expectedScore: 48, // SPF=25 + DKIM=23
 		},
 		{
 			name: "SPF fail, DKIM pass",
-			results: &model.AuthenticationResults{
-				Spf: &model.AuthResult{
-					Result: model.AuthResultResultFail,
+			results: &api.AuthenticationResults{
+				Spf: &api.AuthResult{
+					Result: api.AuthResultResultFail,
 				},
-				Dkim: &[]model.AuthResult{
-					{Result: model.AuthResultResultPass},
+				Dkim: &[]api.AuthResult{
+					{Result: api.AuthResultResultPass},
 				},
 			},
 			expectedScore: 23, // SPF=0 + DKIM=23
 		},
 		{
 			name: "SPF softfail",
-			results: &model.AuthenticationResults{
-				Spf: &model.AuthResult{
-					Result: model.AuthResultResultSoftfail,
+			results: &api.AuthenticationResults{
+				Spf: &api.AuthResult{
+					Result: api.AuthResultResultSoftfail,
 				},
 			},
 			expectedScore: 4,
 		},
 		{
 			name:          "No authentication",
-			results:       &model.AuthenticationResults{},
+			results:       &api.AuthenticationResults{},
 			expectedScore: 0,
 		},
 		{
 			name: "BIMI adds to score",
-			results: &model.AuthenticationResults{
-				Spf: &model.AuthResult{
-					Result: model.AuthResultResultPass,
+			results: &api.AuthenticationResults{
+				Spf: &api.AuthResult{
+					Result: api.AuthResultResultPass,
 				},
-				Bimi: &model.AuthResult{
-					Result: model.AuthResultResultPass,
+				Bimi: &api.AuthResult{
+					Result: api.AuthResultResultPass,
 				},
 			},
 			expectedScore: 35, // SPF (25) + BIMI (10)
@ -118,30 +117,30 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
 	tests := []struct {
 		name                string
 		header              string
-		expectedSPFResult   *model.AuthResultResult
+		expectedSPFResult   *api.AuthResultResult
 		expectedSPFDomain   *string
 		expectedDKIMCount   int
-		expectedDKIMResult  *model.AuthResultResult
-		expectedDMARCResult *model.AuthResultResult
+		expectedDKIMResult  *api.AuthResultResult
+		expectedDMARCResult *api.AuthResultResult
 		expectedDMARCDomain *string
-		expectedBIMIResult  *model.AuthResultResult
-		expectedARCResult   *model.ARCResultResult
+		expectedBIMIResult  *api.AuthResultResult
+		expectedARCResult   *api.ARCResultResult
 	}{
 		{
 			name:                "Complete authentication results",
 			header:              "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultPass),
-			expectedSPFDomain:   utils.PtrTo("example.com"),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultPass),
+			expectedSPFDomain:   api.PtrTo("example.com"),
 			expectedDKIMCount:   1,
-			expectedDKIMResult:  utils.PtrTo(model.AuthResultResultPass),
-			expectedDMARCResult: utils.PtrTo(model.AuthResultResultPass),
-			expectedDMARCDomain: utils.PtrTo("example.com"),
+			expectedDKIMResult:  api.PtrTo(api.AuthResultResultPass),
+			expectedDMARCResult: api.PtrTo(api.AuthResultResultPass),
+			expectedDMARCDomain: api.PtrTo("example.com"),
 		},
 		{
 			name:                "SPF only",
 			header:              "mail.example.com; spf=pass smtp.mailfrom=user@domain.com",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultPass),
-			expectedSPFDomain:   utils.PtrTo("domain.com"),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultPass),
+			expectedSPFDomain:   api.PtrTo("domain.com"),
 			expectedDKIMCount:   0,
 			expectedDMARCResult: nil,
 		},
@ -150,68 +149,68 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
 			header:             "mail.example.com; dkim=pass header.d=example.com header.s=selector1",
 			expectedSPFResult:  nil,
 			expectedDKIMCount:  1,
-			expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
+			expectedDKIMResult: api.PtrTo(api.AuthResultResultPass),
 		},
 		{
 			name:                "Multiple DKIM signatures",
 			header:              "mail.example.com; dkim=pass header.d=example.com header.s=s1; dkim=pass header.d=example.com header.s=s2",
 			expectedSPFResult:   nil,
 			expectedDKIMCount:   2,
-			expectedDKIMResult:  utils.PtrTo(model.AuthResultResultPass),
+			expectedDKIMResult:  api.PtrTo(api.AuthResultResultPass),
 			expectedDMARCResult: nil,
 		},
 		{
 			name:                "SPF fail with DKIM pass",
 			header:              "mail.example.com; spf=fail smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultFail),
-			expectedSPFDomain:   utils.PtrTo("example.com"),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultFail),
+			expectedSPFDomain:   api.PtrTo("example.com"),
 			expectedDKIMCount:   1,
-			expectedDKIMResult:  utils.PtrTo(model.AuthResultResultPass),
+			expectedDKIMResult:  api.PtrTo(api.AuthResultResultPass),
 			expectedDMARCResult: nil,
 		},
 		{
 			name:                "SPF softfail",
 			header:              "mail.example.com; spf=softfail smtp.mailfrom=sender@example.com",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultSoftfail),
-			expectedSPFDomain:   utils.PtrTo("example.com"),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultSoftfail),
+			expectedSPFDomain:   api.PtrTo("example.com"),
 			expectedDKIMCount:   0,
 			expectedDMARCResult: nil,
 		},
 		{
 			name:                "DMARC fail",
 			header:              "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=fail action=quarantine header.from=example.com",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultPass),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultPass),
 			expectedDKIMCount:   1,
-			expectedDKIMResult:  utils.PtrTo(model.AuthResultResultPass),
-			expectedDMARCResult: utils.PtrTo(model.AuthResultResultFail),
-			expectedDMARCDomain: utils.PtrTo("example.com"),
+			expectedDKIMResult:  api.PtrTo(api.AuthResultResultPass),
+			expectedDMARCResult: api.PtrTo(api.AuthResultResultFail),
+			expectedDMARCDomain: api.PtrTo("example.com"),
 		},
 		{
 			name:               "BIMI pass",
 			header:             "mail.example.com; spf=pass smtp.mailfrom=sender@example.com; bimi=pass header.d=example.com header.selector=default",
-			expectedSPFResult:  utils.PtrTo(model.AuthResultResultPass),
-			expectedSPFDomain:  utils.PtrTo("example.com"),
+			expectedSPFResult:  api.PtrTo(api.AuthResultResultPass),
+			expectedSPFDomain:  api.PtrTo("example.com"),
 			expectedDKIMCount:  0,
-			expectedBIMIResult: utils.PtrTo(model.AuthResultResultPass),
+			expectedBIMIResult: api.PtrTo(api.AuthResultResultPass),
 		},
 		{
 			name:              "ARC pass",
 			header:            "mail.example.com; arc=pass",
 			expectedSPFResult: nil,
 			expectedDKIMCount: 0,
-			expectedARCResult: utils.PtrTo(model.ARCResultResultPass),
+			expectedARCResult: api.PtrTo(api.ARCResultResultPass),
 		},
 		{
 			name:                "All authentication methods",
 			header:              "mx.google.com; spf=pass smtp.mailfrom=sender@example.com; dkim=pass header.d=example.com header.s=default; dmarc=pass action=none header.from=example.com; bimi=pass header.d=example.com header.selector=v1; arc=pass",
-			expectedSPFResult:   utils.PtrTo(model.AuthResultResultPass),
-			expectedSPFDomain:   utils.PtrTo("example.com"),
+			expectedSPFResult:   api.PtrTo(api.AuthResultResultPass),
+			expectedSPFDomain:   api.PtrTo("example.com"),
 			expectedDKIMCount:   1,
-			expectedDKIMResult:  utils.PtrTo(model.AuthResultResultPass),
-			expectedDMARCResult: utils.PtrTo(model.AuthResultResultPass),
-			expectedDMARCDomain: utils.PtrTo("example.com"),
-			expectedBIMIResult:  utils.PtrTo(model.AuthResultResultPass),
-			expectedARCResult:   utils.PtrTo(model.ARCResultResultPass),
+			expectedDKIMResult:  api.PtrTo(api.AuthResultResultPass),
+			expectedDMARCResult: api.PtrTo(api.AuthResultResultPass),
+			expectedDMARCDomain: api.PtrTo("example.com"),
+			expectedBIMIResult:  api.PtrTo(api.AuthResultResultPass),
+			expectedARCResult:   api.PtrTo(api.ARCResultResultPass),
 		},
 		{
 			name:              "Empty header (authserv-id only)",
@ -222,8 +221,8 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
 		{
 			name:              "Empty parts with semicolons",
 			header:            "mx.google.com; ; ; spf=pass smtp.mailfrom=sender@example.com; ;",
-			expectedSPFResult: utils.PtrTo(model.AuthResultResultPass),
-			expectedSPFDomain: utils.PtrTo("example.com"),
+			expectedSPFResult: api.PtrTo(api.AuthResultResultPass),
+			expectedSPFDomain: api.PtrTo("example.com"),
 			expectedDKIMCount: 0,
 		},
 		{
@ -231,19 +230,19 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {
 			header:             "mail.example.com; dkim=pass d=example.com s=selector1",
 			expectedSPFResult:  nil,
 			expectedDKIMCount:  1,
-			expectedDKIMResult: utils.PtrTo(model.AuthResultResultPass),
+			expectedDKIMResult: api.PtrTo(api.AuthResultResultPass),
 		},
 		{
 			name:              "SPF neutral",
 			header:            "mail.example.com; spf=neutral smtp.mailfrom=sender@example.com",
-			expectedSPFResult: utils.PtrTo(model.AuthResultResultNeutral),
-			expectedSPFDomain: utils.PtrTo("example.com"),
+			expectedSPFResult: api.PtrTo(api.AuthResultResultNeutral),
+			expectedSPFDomain: api.PtrTo("example.com"),
 			expectedDKIMCount: 0,
 		},
 		{
 			name:              "SPF none",
 			header:            "mail.example.com; spf=none",
-			expectedSPFResult: utils.PtrTo(model.AuthResultResultNone),
+			expectedSPFResult: api.PtrTo(api.AuthResultResultNone),
 			expectedDKIMCount: 0,
 		},
 	}
@ -252,7 +251,7 @@ func TestParseAuthenticationResultsHeader(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			results := &model.AuthenticationResults{}
+			results := &api.AuthenticationResults{}
 			analyzer.parseAuthenticationResultsHeader(tt.header, results)

 			// Check SPF
@ -358,13 +357,13 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {

 	t.Run("Multiple SPF results - only first is parsed", func(t *testing.T) {
 		header := "mail.example.com; spf=pass smtp.mailfrom=first@example.com; spf=fail smtp.mailfrom=second@example.com"
-		results := &model.AuthenticationResults{}
+		results := &api.AuthenticationResults{}
 		analyzer.parseAuthenticationResultsHeader(header, results)

 		if results.Spf == nil {
 			t.Fatal("Expected SPF result, got nil")
 		}
-		if results.Spf.Result != model.AuthResultResultPass {
+		if results.Spf.Result != api.AuthResultResultPass {
 			t.Errorf("Expected first SPF result (pass), got %v", results.Spf.Result)
 		}
 		if results.Spf.Domain == nil || *results.Spf.Domain != "example.com" {
@ -374,13 +373,13 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {

 	t.Run("Multiple DMARC results - only first is parsed", func(t *testing.T) {
 		header := "mail.example.com; dmarc=pass header.from=first.com; dmarc=fail header.from=second.com"
-		results := &model.AuthenticationResults{}
+		results := &api.AuthenticationResults{}
 		analyzer.parseAuthenticationResultsHeader(header, results)

 		if results.Dmarc == nil {
 			t.Fatal("Expected DMARC result, got nil")
 		}
-		if results.Dmarc.Result != model.AuthResultResultPass {
+		if results.Dmarc.Result != api.AuthResultResultPass {
 			t.Errorf("Expected first DMARC result (pass), got %v", results.Dmarc.Result)
 		}
 		if results.Dmarc.Domain == nil || *results.Dmarc.Domain != "first.com" {
@ -390,26 +389,26 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {

 	t.Run("Multiple ARC results - only first is parsed", func(t *testing.T) {
 		header := "mail.example.com; arc=pass; arc=fail"
-		results := &model.AuthenticationResults{}
+		results := &api.AuthenticationResults{}
 		analyzer.parseAuthenticationResultsHeader(header, results)

 		if results.Arc == nil {
 			t.Fatal("Expected ARC result, got nil")
 		}
-		if results.Arc.Result != model.ARCResultResultPass {
+		if results.Arc.Result != api.ARCResultResultPass {
 			t.Errorf("Expected first ARC result (pass), got %v", results.Arc.Result)
 		}
 	})

 	t.Run("Multiple BIMI results - only first is parsed", func(t *testing.T) {
 		header := "mail.example.com; bimi=pass header.d=first.com; bimi=fail header.d=second.com"
-		results := &model.AuthenticationResults{}
+		results := &api.AuthenticationResults{}
 		analyzer.parseAuthenticationResultsHeader(header, results)

 		if results.Bimi == nil {
 			t.Fatal("Expected BIMI result, got nil")
 		}
-		if results.Bimi.Result != model.AuthResultResultPass {
+		if results.Bimi.Result != api.AuthResultResultPass {
 			t.Errorf("Expected first BIMI result (pass), got %v", results.Bimi.Result)
 		}
 		if results.Bimi.Domain == nil || *results.Bimi.Domain != "first.com" {
@ -420,7 +419,7 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
 	t.Run("Multiple DKIM results - all are parsed", func(t *testing.T) {
 		// DKIM is special - multiple signatures should all be collected
 		header := "mail.example.com; dkim=pass header.d=first.com header.s=s1; dkim=fail header.d=second.com header.s=s2"
-		results := &model.AuthenticationResults{}
+		results := &api.AuthenticationResults{}
 		analyzer.parseAuthenticationResultsHeader(header, results)

 		if results.Dkim == nil {
@ -429,10 +428,10 @@ func TestParseAuthenticationResultsHeader_OnlyFirstResultParsed(t *testing.T) {
 		if len(*results.Dkim) != 2 {
 			t.Errorf("Expected 2 DKIM results, got %d", len(*results.Dkim))
 		}
-		if (*results.Dkim)[0].Result != model.AuthResultResultPass {
+		if (*results.Dkim)[0].Result != api.AuthResultResultPass {
 			t.Errorf("Expected first DKIM result to be pass, got %v", (*results.Dkim)[0].Result)
 		}
-		if (*results.Dkim)[1].Result != model.AuthResultResultFail {
+		if (*results.Dkim)[1].Result != api.AuthResultResultFail {
 			t.Errorf("Expected second DKIM result to be fail, got %v", (*results.Dkim)[1].Result)
 		}
 	})
--- a/pkg/analyzer/authentication_x_aligned_from.go
+++ b/pkg/analyzer/authentication_x_aligned_from.go
@ -25,35 +25,34 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseXAlignedFromResult parses X-Aligned-From result from Authentication-Results
 // Example: x-aligned-from=pass (Address match)
-func (a *AuthenticationAnalyzer) parseXAlignedFromResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseXAlignedFromResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`x-aligned-from=([\w]+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract details (everything after the result)
-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "x-aligned-from="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "x-aligned-from="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateXAlignedFromScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateXAlignedFromScore(results *api.AuthenticationResults) (score int) {
 	if results.XAlignedFrom != nil {
 		switch results.XAlignedFrom.Result {
-		case model.AuthResultResultPass:
+		case api.AuthResultResultPass:
 			// pass: positive contribution
 			return 100
-		case model.AuthResultResultFail:
+		case api.AuthResultResultFail:
 			// fail: negative contribution
 			return 0
 		default:
--- a/pkg/analyzer/authentication_x_aligned_from_test.go
+++ b/pkg/analyzer/authentication_x_aligned_from_test.go
@ -24,44 +24,44 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseXAlignedFromResult(t *testing.T) {
 	tests := []struct {
 		name           string
 		part           string
-		expectedResult model.AuthResultResult
+		expectedResult api.AuthResultResult
 		expectedDetail string
 	}{
 		{
 			name:           "x-aligned-from pass with details",
 			part:           "x-aligned-from=pass (Address match)",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDetail: "pass (Address match)",
 		},
 		{
 			name:           "x-aligned-from fail with reason",
 			part:           "x-aligned-from=fail (Address mismatch)",
-			expectedResult: model.AuthResultResultFail,
+			expectedResult: api.AuthResultResultFail,
 			expectedDetail: "fail (Address mismatch)",
 		},
 		{
 			name:           "x-aligned-from pass minimal",
 			part:           "x-aligned-from=pass",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDetail: "pass",
 		},
 		{
 			name:           "x-aligned-from neutral",
 			part:           "x-aligned-from=neutral (No alignment check performed)",
-			expectedResult: model.AuthResultResultNeutral,
+			expectedResult: api.AuthResultResultNeutral,
 			expectedDetail: "neutral (No alignment check performed)",
 		},
 		{
 			name:           "x-aligned-from none",
 			part:           "x-aligned-from=none",
-			expectedResult: model.AuthResultResultNone,
+			expectedResult: api.AuthResultResultNone,
 			expectedDetail: "none",
 		},
 	}
@ -88,34 +88,34 @@ func TestParseXAlignedFromResult(t *testing.T) {
 func TestCalculateXAlignedFromScore(t *testing.T) {
 	tests := []struct {
 		name          string
-		result        *model.AuthResult
+		result        *api.AuthResult
 		expectedScore int
 	}{
 		{
 			name: "pass result gives positive score",
-			result: &model.AuthResult{
-				Result: model.AuthResultResultPass,
+			result: &api.AuthResult{
+				Result: api.AuthResultResultPass,
 			},
 			expectedScore: 100,
 		},
 		{
 			name: "fail result gives zero score",
-			result: &model.AuthResult{
-				Result: model.AuthResultResultFail,
+			result: &api.AuthResult{
+				Result: api.AuthResultResultFail,
 			},
 			expectedScore: 0,
 		},
 		{
 			name: "neutral result gives zero score",
-			result: &model.AuthResult{
-				Result: model.AuthResultResultNeutral,
+			result: &api.AuthResult{
+				Result: api.AuthResultResultNeutral,
 			},
 			expectedScore: 0,
 		},
 		{
 			name: "none result gives zero score",
-			result: &model.AuthResult{
-				Result: model.AuthResultResultNone,
+			result: &api.AuthResult{
+				Result: api.AuthResultResultNone,
 			},
 			expectedScore: 0,
 		},
@ -130,7 +130,7 @@ func TestCalculateXAlignedFromScore(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			results := &model.AuthenticationResults{
+			results := &api.AuthenticationResults{
 				XAlignedFrom: tt.result,
 			}

--- a/pkg/analyzer/authentication_x_google_dkim.go
+++ b/pkg/analyzer/authentication_x_google_dkim.go
@ -25,20 +25,19 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // parseXGoogleDKIMResult parses Google DKIM result from Authentication-Results
 // Example: x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6
-func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *model.AuthResult {
-	result := &model.AuthResult{}
+func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *api.AuthResult {
+	result := &api.AuthResult{}

 	// Extract result (pass, fail, etc.)
 	re := regexp.MustCompile(`x-google-dkim=(\w+)`)
 	if matches := re.FindStringSubmatch(part); len(matches) > 1 {
 		resultStr := strings.ToLower(matches[1])
-		result.Result = model.AuthResultResult(resultStr)
+		result.Result = api.AuthResultResult(resultStr)
 	}

 	// Extract domain (header.d or d)
@ -55,15 +54,15 @@ func (a *AuthenticationAnalyzer) parseXGoogleDKIMResult(part string) *model.Auth
 		result.Selector = &selector
 	}

-	result.Details = utils.PtrTo(strings.TrimPrefix(part, "x-google-dkim="))
+	result.Details = api.PtrTo(strings.TrimPrefix(part, "x-google-dkim="))

 	return result
 }

-func (a *AuthenticationAnalyzer) calculateXGoogleDKIMScore(results *model.AuthenticationResults) (score int) {
+func (a *AuthenticationAnalyzer) calculateXGoogleDKIMScore(results *api.AuthenticationResults) (score int) {
 	if results.XGoogleDkim != nil {
 		switch results.XGoogleDkim.Result {
-		case model.AuthResultResultPass:
+		case api.AuthResultResultPass:
 			// pass: don't alter the score
 		default: // fail
 			return -100
--- a/pkg/analyzer/authentication_x_google_dkim_test.go
+++ b/pkg/analyzer/authentication_x_google_dkim_test.go
@ -24,39 +24,39 @@ package analyzer
 import (
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseXGoogleDKIMResult(t *testing.T) {
 	tests := []struct {
 		name             string
 		part             string
-		expectedResult   model.AuthResultResult
+		expectedResult   api.AuthResultResult
 		expectedDomain   string
 		expectedSelector string
 	}{
 		{
 			name:           "x-google-dkim pass with domain",
 			part:           "x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=fauiPVZ6",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDomain: "1e100.net",
 		},
 		{
 			name:           "x-google-dkim pass with short form",
 			part:           "x-google-dkim=pass d=gmail.com",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 			expectedDomain: "gmail.com",
 		},
 		{
 			name:           "x-google-dkim fail",
 			part:           "x-google-dkim=fail header.d=example.com",
-			expectedResult: model.AuthResultResultFail,
+			expectedResult: api.AuthResultResultFail,
 			expectedDomain: "example.com",
 		},
 		{
 			name:           "x-google-dkim with minimal info",
 			part:           "x-google-dkim=pass",
-			expectedResult: model.AuthResultResultPass,
+			expectedResult: api.AuthResultResultPass,
 		},
 	}

--- a/pkg/analyzer/content.go
+++ b/pkg/analyzer/content.go
@ -32,8 +32,7 @@ import (
 	"time"
 	"unicode"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 	"golang.org/x/net/html"
 )

@ -729,16 +728,16 @@ func (c *ContentAnalyzer) normalizeText(text string) string {
 }

 // GenerateContentAnalysis creates structured content analysis from results
-func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *model.ContentAnalysis {
+func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *api.ContentAnalysis {
 	if results == nil {
 		return nil
 	}

-	analysis := &model.ContentAnalysis{
-		HasHtml:            utils.PtrTo(results.HTMLContent != ""),
-		HasPlaintext:       utils.PtrTo(results.TextContent != ""),
-		HasUnsubscribeLink: utils.PtrTo(results.HasUnsubscribe),
-		UnsubscribeMethods: &[]model.ContentAnalysisUnsubscribeMethods{},
+	analysis := &api.ContentAnalysis{
+		HasHtml:            api.PtrTo(results.HTMLContent != ""),
+		HasPlaintext:       api.PtrTo(results.TextContent != ""),
+		HasUnsubscribeLink: api.PtrTo(results.HasUnsubscribe),
+		UnsubscribeMethods: &[]api.ContentAnalysisUnsubscribeMethods{},
 	}

 	// Calculate text-to-image ratio (inverse of image-to-text)
@ -751,16 +750,16 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode
 	}

 	// Build HTML issues
-	htmlIssues := []model.ContentIssue{}
+	htmlIssues := []api.ContentIssue{}

 	// Add HTML parsing errors
 	if !results.HTMLValid && len(results.HTMLErrors) > 0 {
 		for _, errMsg := range results.HTMLErrors {
-			htmlIssues = append(htmlIssues, model.ContentIssue{
-				Type:     model.BrokenHtml,
-				Severity: model.ContentIssueSeverityHigh,
+			htmlIssues = append(htmlIssues, api.ContentIssue{
+				Type:     api.BrokenHtml,
+				Severity: api.ContentIssueSeverityHigh,
 				Message:  errMsg,
-				Advice:   utils.PtrTo("Fix HTML structure errors to improve email rendering across clients"),
+				Advice:   api.PtrTo("Fix HTML structure errors to improve email rendering across clients"),
 			})
 		}
 	}
@ -774,53 +773,53 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode
 			}
 		}
 		if missingAltCount > 0 {
-			htmlIssues = append(htmlIssues, model.ContentIssue{
-				Type:     model.MissingAlt,
-				Severity: model.ContentIssueSeverityMedium,
+			htmlIssues = append(htmlIssues, api.ContentIssue{
+				Type:     api.MissingAlt,
+				Severity: api.ContentIssueSeverityMedium,
 				Message:  fmt.Sprintf("%d image(s) missing alt attributes", missingAltCount),
-				Advice:   utils.PtrTo("Add descriptive alt text to all images for better accessibility and deliverability"),
+				Advice:   api.PtrTo("Add descriptive alt text to all images for better accessibility and deliverability"),
 			})
 		}
 	}

 	// Add excessive images issue
 	if results.ImageTextRatio > 10.0 {
-		htmlIssues = append(htmlIssues, model.ContentIssue{
-			Type:     model.ExcessiveImages,
-			Severity: model.ContentIssueSeverityMedium,
+		htmlIssues = append(htmlIssues, api.ContentIssue{
+			Type:     api.ExcessiveImages,
+			Severity: api.ContentIssueSeverityMedium,
 			Message:  "Email is excessively image-heavy",
-			Advice:   utils.PtrTo("Reduce the number of images relative to text content"),
+			Advice:   api.PtrTo("Reduce the number of images relative to text content"),
 		})
 	}

 	// Add suspicious URL issues
 	for _, suspURL := range results.SuspiciousURLs {
-		htmlIssues = append(htmlIssues, model.ContentIssue{
-			Type:     model.SuspiciousLink,
-			Severity: model.ContentIssueSeverityHigh,
+		htmlIssues = append(htmlIssues, api.ContentIssue{
+			Type:     api.SuspiciousLink,
+			Severity: api.ContentIssueSeverityHigh,
 			Message:  "Suspicious URL detected",
 			Location: &suspURL,
-			Advice:   utils.PtrTo("Avoid URL shorteners, IP addresses, and obfuscated URLs in emails"),
+			Advice:   api.PtrTo("Avoid URL shorteners, IP addresses, and obfuscated URLs in emails"),
 		})
 	}

 	// Add harmful HTML tag issues
 	for _, harmfulIssue := range results.HarmfullIssues {
-		htmlIssues = append(htmlIssues, model.ContentIssue{
-			Type:     model.DangerousHtml,
-			Severity: model.ContentIssueSeverityCritical,
+		htmlIssues = append(htmlIssues, api.ContentIssue{
+			Type:     api.DangerousHtml,
+			Severity: api.ContentIssueSeverityCritical,
 			Message:  harmfulIssue,
-			Advice:   utils.PtrTo("Remove dangerous HTML tags like <script>, <iframe>, <object>, <embed>, <applet>, <form>, and <base> from email content"),
+			Advice:   api.PtrTo("Remove dangerous HTML tags like <script>, <iframe>, <object>, <embed>, <applet>, <form>, and <base> from email content"),
 		})
 	}

 	// Add general content issues (like external stylesheets)
 	for _, contentIssue := range results.ContentIssues {
-		htmlIssues = append(htmlIssues, model.ContentIssue{
-			Type:     model.BrokenHtml,
-			Severity: model.ContentIssueSeverityLow,
+		htmlIssues = append(htmlIssues, api.ContentIssue{
+			Type:     api.BrokenHtml,
+			Severity: api.ContentIssueSeverityLow,
 			Message:  contentIssue,
-			Advice:   utils.PtrTo("Use inline CSS instead of external stylesheets for better email compatibility"),
+			Advice:   api.PtrTo("Use inline CSS instead of external stylesheets for better email compatibility"),
 		})
 	}

@ -830,31 +829,31 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode

 	// Convert links
 	if len(results.Links) > 0 {
-		links := make([]model.LinkCheck, 0, len(results.Links))
+		links := make([]api.LinkCheck, 0, len(results.Links))
 		for _, link := range results.Links {
-			status := model.Valid
+			status := api.Valid
 			if link.Status >= 400 {
-				status = model.Broken
+				status = api.Broken
 			} else if !link.IsSafe {
-				status = model.Suspicious
+				status = api.Suspicious
 			} else if link.Warning != "" {
-				status = model.Timeout
+				status = api.Timeout
 			}

-			apiLink := model.LinkCheck{
+			apiLink := api.LinkCheck{
 				Url:    link.URL,
 				Status: status,
 			}

 			if link.Status > 0 {
-				apiLink.HttpCode = utils.PtrTo(link.Status)
+				apiLink.HttpCode = api.PtrTo(link.Status)
 			}

 			// Check if it's a URL shortener
 			parsedURL, err := url.Parse(link.URL)
 			if err == nil {
 				isShortened := c.isSuspiciousURL(link.URL, parsedURL)
-				apiLink.IsShortened = utils.PtrTo(isShortened)
+				apiLink.IsShortened = api.PtrTo(isShortened)
 			}

 			links = append(links, apiLink)
@ -864,9 +863,9 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode

 	// Convert images
 	if len(results.Images) > 0 {
-		images := make([]model.ImageCheck, 0, len(results.Images))
+		images := make([]api.ImageCheck, 0, len(results.Images))
 		for _, img := range results.Images {
-			apiImg := model.ImageCheck{
+			apiImg := api.ImageCheck{
 				HasAlt: img.HasAlt,
 			}
 			if img.Src != "" {
@ -876,7 +875,7 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode
 				apiImg.AltText = &img.AltText
 			}
 			// Simple heuristic: tracking pixels are typically 1x1
-			apiImg.IsTrackingPixel = utils.PtrTo(false)
+			apiImg.IsTrackingPixel = api.PtrTo(false)

 			images = append(images, apiImg)
 		}
@ -885,19 +884,19 @@ func (c *ContentAnalyzer) GenerateContentAnalysis(results *ContentResults) *mode

 	// Unsubscribe methods
 	if results.HasUnsubscribe {
-		*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.Link)
+		*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.Link)
 	}

 	for _, url := range c.listUnsubscribeURLs {
 		if strings.HasPrefix(url, "mailto:") {
-			*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.Mailto)
+			*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.Mailto)
 		} else if strings.HasPrefix(url, "http:") || strings.HasPrefix(url, "https:") {
-			*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.ListUnsubscribeHeader)
+			*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.ListUnsubscribeHeader)
 		}
 	}

-	if slices.Contains(*analysis.UnsubscribeMethods, model.ListUnsubscribeHeader) && c.hasOneClickUnsubscribe {
-		*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, model.OneClick)
+	if slices.Contains(*analysis.UnsubscribeMethods, api.ListUnsubscribeHeader) && c.hasOneClickUnsubscribe {
+		*analysis.UnsubscribeMethods = append(*analysis.UnsubscribeMethods, api.OneClick)
 	}

 	return analysis
--- a/pkg/analyzer/dns.go
+++ b/pkg/analyzer/dns.go
@ -24,7 +24,7 @@ package analyzer
 import (
 	"time"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // DNSAnalyzer analyzes DNS records for email domains
@ -54,16 +54,16 @@ func NewDNSAnalyzerWithResolver(timeout time.Duration, resolver DNSResolver) *DN
 }

 // AnalyzeDNS performs DNS validation for the email's domain
-func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, headersResults *model.HeaderAnalysis) *model.DNSResults {
+func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, headersResults *api.HeaderAnalysis) *api.DNSResults {
 	// Extract domain from From address
 	if headersResults.DomainAlignment.FromDomain == nil || *headersResults.DomainAlignment.FromDomain == "" {
-		return &model.DNSResults{
+		return &api.DNSResults{
 			Errors: &[]string{"Unable to extract domain from email"},
 		}
 	}
 	fromDomain := *headersResults.DomainAlignment.FromDomain

-	results := &model.DNSResults{
+	results := &api.DNSResults{
 		FromDomain: fromDomain,
 		RpDomain:   headersResults.DomainAlignment.ReturnPathDomain,
 	}
@ -109,7 +109,7 @@ func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, headersResults *model.Head
 		dkimRecord := d.checkDKIMRecord(sig.Domain, sig.Selector)
 		if dkimRecord != nil {
 			if results.DkimRecords == nil {
-				results.DkimRecords = new([]model.DKIMRecord)
+				results.DkimRecords = new([]api.DKIMRecord)
 			}
 			*results.DkimRecords = append(*results.DkimRecords, *dkimRecord)
 		}
@ -127,8 +127,8 @@ func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, headersResults *model.Head

 // AnalyzeDomainOnly performs DNS validation for a domain without email context
 // This is useful for checking domain configuration without sending an actual email
-func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *model.DNSResults {
-	results := &model.DNSResults{
+func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *api.DNSResults {
+	results := &api.DNSResults{
 		FromDomain: domain,
 	}

@ -150,7 +150,7 @@ func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *model.DNSResults {
 // CalculateDomainOnlyScore calculates the DNS score for domain-only tests
 // Returns a score from 0-100 where higher is better
 // This version excludes PTR and DKIM checks since they require email context
-func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *model.DNSResults) (int, string) {
+func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *api.DNSResults) (int, string) {
 	if results == nil {
 		return 0, ""
 	}
@ -192,7 +192,7 @@ func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *model.DNSResults) (int,
 // CalculateDNSScore calculates the DNS score from records results
 // Returns a score from 0-100 where higher is better
 // senderIP is the original sender IP address used for FCrDNS verification
-func (d *DNSAnalyzer) CalculateDNSScore(results *model.DNSResults, senderIP string) (int, string) {
+func (d *DNSAnalyzer) CalculateDNSScore(results *api.DNSResults, senderIP string) (int, string) {
 	if results == nil {
 		return 0, ""
 	}
--- a/pkg/analyzer/dns_bimi.go
+++ b/pkg/analyzer/dns_bimi.go
@ -27,12 +27,11 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // checkBIMIRecord looks up and validates BIMI record for a domain and selector
-func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *model.BIMIRecord {
+func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *api.BIMIRecord {
 	// BIMI records are at: selector._bimi.domain
 	bimiDomain := fmt.Sprintf("%s._bimi.%s", selector, domain)

@ -41,20 +40,20 @@ func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *model.BIMIRecord

 	txtRecords, err := d.resolver.LookupTXT(ctx, bimiDomain)
 	if err != nil {
-		return &model.BIMIRecord{
+		return &api.BIMIRecord{
 			Selector: selector,
 			Domain:   domain,
 			Valid:    false,
-			Error:    utils.PtrTo(fmt.Sprintf("Failed to lookup BIMI record: %v", err)),
+			Error:    api.PtrTo(fmt.Sprintf("Failed to lookup BIMI record: %v", err)),
 		}
 	}

 	if len(txtRecords) == 0 {
-		return &model.BIMIRecord{
+		return &api.BIMIRecord{
 			Selector: selector,
 			Domain:   domain,
 			Valid:    false,
-			Error:    utils.PtrTo("No BIMI record found"),
+			Error:    api.PtrTo("No BIMI record found"),
 		}
 	}

@ -67,18 +66,18 @@ func (d *DNSAnalyzer) checkBIMIRecord(domain, selector string) *model.BIMIRecord

 	// Basic validation - should contain "v=BIMI1" and "l=" (logo URL)
 	if !d.validateBIMI(bimiRecord) {
-		return &model.BIMIRecord{
+		return &api.BIMIRecord{
 			Selector: selector,
 			Domain:   domain,
 			Record:   &bimiRecord,
 			LogoUrl:  &logoURL,
 			VmcUrl:   &vmcURL,
 			Valid:    false,
-			Error:    utils.PtrTo("BIMI record appears malformed"),
+			Error:    api.PtrTo("BIMI record appears malformed"),
 		}
 	}

-	return &model.BIMIRecord{
+	return &api.BIMIRecord{
 		Selector: selector,
 		Domain:   domain,
 		Record:   &bimiRecord,
--- a/pkg/analyzer/dns_dkim.go
+++ b/pkg/analyzer/dns_dkim.go
@ -26,8 +26,7 @@ import (
 	"fmt"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // DKIMHeader holds the domain and selector extracted from a DKIM-Signature header.
@ -62,8 +61,8 @@ func parseDKIMSignatures(signatures []string) []DKIMHeader {
 	return results
 }

-// checkmodel.DKIMRecord looks up and validates DKIM record for a domain and selector
-func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *model.DKIMRecord {
+// checkapi.DKIMRecord looks up and validates DKIM record for a domain and selector
+func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *api.DKIMRecord {
 	// DKIM records are at: selector._domainkey.domain
 	dkimDomain := fmt.Sprintf("%s._domainkey.%s", selector, domain)

@ -72,20 +71,20 @@ func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *model.DKIMRecord

 	txtRecords, err := d.resolver.LookupTXT(ctx, dkimDomain)
 	if err != nil {
-		return &model.DKIMRecord{
+		return &api.DKIMRecord{
 			Selector: selector,
 			Domain:   domain,
 			Valid:    false,
-			Error:    utils.PtrTo(fmt.Sprintf("Failed to lookup DKIM record: %v", err)),
+			Error:    api.PtrTo(fmt.Sprintf("Failed to lookup DKIM record: %v", err)),
 		}
 	}

 	if len(txtRecords) == 0 {
-		return &model.DKIMRecord{
+		return &api.DKIMRecord{
 			Selector: selector,
 			Domain:   domain,
 			Valid:    false,
-			Error:    utils.PtrTo("No DKIM record found"),
+			Error:    api.PtrTo("No DKIM record found"),
 		}
 	}

@ -94,16 +93,16 @@ func (d *DNSAnalyzer) checkDKIMRecord(domain, selector string) *model.DKIMRecord

 	// Basic validation - should contain "v=DKIM1" and "p=" (public key)
 	if !d.validateDKIM(dkimRecord) {
-		return &model.DKIMRecord{
+		return &api.DKIMRecord{
 			Selector: selector,
 			Domain:   domain,
-			Record:   utils.PtrTo(dkimRecord),
+			Record:   api.PtrTo(dkimRecord),
 			Valid:    false,
-			Error:    utils.PtrTo("DKIM record appears malformed"),
+			Error:    api.PtrTo("DKIM record appears malformed"),
 		}
 	}

-	return &model.DKIMRecord{
+	return &api.DKIMRecord{
 		Selector: selector,
 		Domain:   domain,
 		Record:   &dkimRecord,
@ -127,7 +126,7 @@ func (d *DNSAnalyzer) validateDKIM(record string) bool {
 	return true
 }

-func (d *DNSAnalyzer) calculateDKIMScore(results *model.DNSResults) (score int) {
+func (d *DNSAnalyzer) calculateDKIMScore(results *api.DNSResults) (score int) {
 	// DKIM provides strong email authentication
 	if results.DkimRecords != nil && len(*results.DkimRecords) > 0 {
 		hasValidDKIM := false
--- a/pkg/analyzer/dns_dmarc.go
+++ b/pkg/analyzer/dns_dmarc.go
@ -27,12 +27,11 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

-// checkmodel.DMARCRecord looks up and validates DMARC record for a domain
-func (d *DNSAnalyzer) checkDMARCRecord(domain string) *model.DMARCRecord {
+// checkapi.DMARCRecord looks up and validates DMARC record for a domain
+func (d *DNSAnalyzer) checkDMARCRecord(domain string) *api.DMARCRecord {
 	// DMARC records are at: _dmarc.domain
 	dmarcDomain := fmt.Sprintf("_dmarc.%s", domain)

@ -41,9 +40,9 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *model.DMARCRecord {

 	txtRecords, err := d.resolver.LookupTXT(ctx, dmarcDomain)
 	if err != nil {
-		return &model.DMARCRecord{
+		return &api.DMARCRecord{
 			Valid: false,
-			Error: utils.PtrTo(fmt.Sprintf("Failed to lookup DMARC record: %v", err)),
+			Error: api.PtrTo(fmt.Sprintf("Failed to lookup DMARC record: %v", err)),
 		}
 	}

@ -57,9 +56,9 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *model.DMARCRecord {
 	}

 	if dmarcRecord == "" {
-		return &model.DMARCRecord{
+		return &api.DMARCRecord{
 			Valid: false,
-			Error: utils.PtrTo("No DMARC record found"),
+			Error: api.PtrTo("No DMARC record found"),
 		}
 	}

@ -78,21 +77,21 @@ func (d *DNSAnalyzer) checkDMARCRecord(domain string) *model.DMARCRecord {

 	// Basic validation
 	if !d.validateDMARC(dmarcRecord) {
-		return &model.DMARCRecord{
+		return &api.DMARCRecord{
 			Record:          &dmarcRecord,
-			Policy:          utils.PtrTo(model.DMARCRecordPolicy(policy)),
+			Policy:          api.PtrTo(api.DMARCRecordPolicy(policy)),
 			SubdomainPolicy: subdomainPolicy,
 			Percentage:      percentage,
 			SpfAlignment:    spfAlignment,
 			DkimAlignment:   dkimAlignment,
 			Valid:           false,
-			Error:           utils.PtrTo("DMARC record appears malformed"),
+			Error:           api.PtrTo("DMARC record appears malformed"),
 		}
 	}

-	return &model.DMARCRecord{
+	return &api.DMARCRecord{
 		Record:          &dmarcRecord,
-		Policy:          utils.PtrTo(model.DMARCRecordPolicy(policy)),
+		Policy:          api.PtrTo(api.DMARCRecordPolicy(policy)),
 		SubdomainPolicy: subdomainPolicy,
 		Percentage:      percentage,
 		SpfAlignment:    spfAlignment,
@ -114,44 +113,44 @@ func (d *DNSAnalyzer) extractDMARCPolicy(record string) string {

 // extractDMARCSPFAlignment extracts SPF alignment mode from a DMARC record
 // Returns "relaxed" (default) or "strict"
-func (d *DNSAnalyzer) extractDMARCSPFAlignment(record string) *model.DMARCRecordSpfAlignment {
+func (d *DNSAnalyzer) extractDMARCSPFAlignment(record string) *api.DMARCRecordSpfAlignment {
 	// Look for aspf=s (strict) or aspf=r (relaxed)
 	re := regexp.MustCompile(`aspf=(r|s)`)
 	matches := re.FindStringSubmatch(record)
 	if len(matches) > 1 {
 		if matches[1] == "s" {
-			return utils.PtrTo(model.DMARCRecordSpfAlignmentStrict)
+			return api.PtrTo(api.DMARCRecordSpfAlignmentStrict)
 		}
-		return utils.PtrTo(model.DMARCRecordSpfAlignmentRelaxed)
+		return api.PtrTo(api.DMARCRecordSpfAlignmentRelaxed)
 	}
 	// Default is relaxed if not specified
-	return utils.PtrTo(model.DMARCRecordSpfAlignmentRelaxed)
+	return api.PtrTo(api.DMARCRecordSpfAlignmentRelaxed)
 }

 // extractDMARCDKIMAlignment extracts DKIM alignment mode from a DMARC record
 // Returns "relaxed" (default) or "strict"
-func (d *DNSAnalyzer) extractDMARCDKIMAlignment(record string) *model.DMARCRecordDkimAlignment {
+func (d *DNSAnalyzer) extractDMARCDKIMAlignment(record string) *api.DMARCRecordDkimAlignment {
 	// Look for adkim=s (strict) or adkim=r (relaxed)
 	re := regexp.MustCompile(`adkim=(r|s)`)
 	matches := re.FindStringSubmatch(record)
 	if len(matches) > 1 {
 		if matches[1] == "s" {
-			return utils.PtrTo(model.DMARCRecordDkimAlignmentStrict)
+			return api.PtrTo(api.DMARCRecordDkimAlignmentStrict)
 		}
-		return utils.PtrTo(model.DMARCRecordDkimAlignmentRelaxed)
+		return api.PtrTo(api.DMARCRecordDkimAlignmentRelaxed)
 	}
 	// Default is relaxed if not specified
-	return utils.PtrTo(model.DMARCRecordDkimAlignmentRelaxed)
+	return api.PtrTo(api.DMARCRecordDkimAlignmentRelaxed)
 }

 // extractDMARCSubdomainPolicy extracts subdomain policy from a DMARC record
 // Returns the sp tag value or nil if not specified (defaults to main policy)
-func (d *DNSAnalyzer) extractDMARCSubdomainPolicy(record string) *model.DMARCRecordSubdomainPolicy {
+func (d *DNSAnalyzer) extractDMARCSubdomainPolicy(record string) *api.DMARCRecordSubdomainPolicy {
 	// Look for sp=none, sp=quarantine, or sp=reject
 	re := regexp.MustCompile(`sp=(none|quarantine|reject)`)
 	matches := re.FindStringSubmatch(record)
 	if len(matches) > 1 {
-		return utils.PtrTo(model.DMARCRecordSubdomainPolicy(matches[1]))
+		return api.PtrTo(api.DMARCRecordSubdomainPolicy(matches[1]))
 	}
 	// If sp is not specified, it defaults to the main policy (p tag)
 	// Return nil to indicate it's using the default
@ -192,7 +191,7 @@ func (d *DNSAnalyzer) validateDMARC(record string) bool {
 	return true
 }

-func (d *DNSAnalyzer) calculateDMARCScore(results *model.DNSResults) (score int) {
+func (d *DNSAnalyzer) calculateDMARCScore(results *api.DNSResults) (score int) {
 	// DMARC ties SPF and DKIM together and provides policy
 	if results.DmarcRecord != nil {
 		if results.DmarcRecord.Valid {
@ -211,10 +210,10 @@ func (d *DNSAnalyzer) calculateDMARCScore(results *model.DNSResults) (score int)
 				}
 			}
 			// Bonus points for strict alignment modes (2 points each)
-			if results.DmarcRecord.SpfAlignment != nil && *results.DmarcRecord.SpfAlignment == model.DMARCRecordSpfAlignmentStrict {
+			if results.DmarcRecord.SpfAlignment != nil && *results.DmarcRecord.SpfAlignment == api.DMARCRecordSpfAlignmentStrict {
 				score += 5
 			}
-			if results.DmarcRecord.DkimAlignment != nil && *results.DmarcRecord.DkimAlignment == model.DMARCRecordDkimAlignmentStrict {
+			if results.DmarcRecord.DkimAlignment != nil && *results.DmarcRecord.DkimAlignment == api.DMARCRecordDkimAlignmentStrict {
 				score += 5
 			}
 			// Subdomain policy scoring (sp tag)
--- a/pkg/analyzer/dns_dmarc_test.go
+++ b/pkg/analyzer/dns_dmarc_test.go
@ -25,8 +25,7 @@ import (
 	"testing"
 	"time"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestExtractDMARCPolicy(t *testing.T) {
@ -229,17 +228,17 @@ func TestExtractDMARCSubdomainPolicy(t *testing.T) {
 		{
 			name:           "Subdomain policy - none",
 			record:         "v=DMARC1; p=quarantine; sp=none",
-			expectedPolicy: utils.PtrTo("none"),
+			expectedPolicy: api.PtrTo("none"),
 		},
 		{
 			name:           "Subdomain policy - quarantine",
 			record:         "v=DMARC1; p=reject; sp=quarantine",
-			expectedPolicy: utils.PtrTo("quarantine"),
+			expectedPolicy: api.PtrTo("quarantine"),
 		},
 		{
 			name:           "Subdomain policy - reject",
 			record:         "v=DMARC1; p=quarantine; sp=reject",
-			expectedPolicy: utils.PtrTo("reject"),
+			expectedPolicy: api.PtrTo("reject"),
 		},
 		{
 			name:           "No subdomain policy specified (defaults to main policy)",
@ -249,7 +248,7 @@ func TestExtractDMARCSubdomainPolicy(t *testing.T) {
 		{
 			name:           "Complex record with subdomain policy",
 			record:         "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=100",
-			expectedPolicy: utils.PtrTo("quarantine"),
+			expectedPolicy: api.PtrTo("quarantine"),
 		},
 	}

@ -283,22 +282,22 @@ func TestExtractDMARCPercentage(t *testing.T) {
 		{
 			name:               "Percentage - 100",
 			record:             "v=DMARC1; p=quarantine; pct=100",
-			expectedPercentage: utils.PtrTo(100),
+			expectedPercentage: api.PtrTo(100),
 		},
 		{
 			name:               "Percentage - 50",
 			record:             "v=DMARC1; p=quarantine; pct=50",
-			expectedPercentage: utils.PtrTo(50),
+			expectedPercentage: api.PtrTo(50),
 		},
 		{
 			name:               "Percentage - 25",
 			record:             "v=DMARC1; p=reject; pct=25",
-			expectedPercentage: utils.PtrTo(25),
+			expectedPercentage: api.PtrTo(25),
 		},
 		{
 			name:               "Percentage - 0",
 			record:             "v=DMARC1; p=none; pct=0",
-			expectedPercentage: utils.PtrTo(0),
+			expectedPercentage: api.PtrTo(0),
 		},
 		{
 			name:               "No percentage specified (defaults to 100)",
@ -308,7 +307,7 @@ func TestExtractDMARCPercentage(t *testing.T) {
 		{
 			name:               "Complex record with percentage",
 			record:             "v=DMARC1; p=reject; sp=quarantine; rua=mailto:dmarc@example.com; pct=75",
-			expectedPercentage: utils.PtrTo(75),
+			expectedPercentage: api.PtrTo(75),
 		},
 		{
 			name:               "Invalid percentage > 100 (ignored)",
--- a/pkg/analyzer/dns_fcr.go
+++ b/pkg/analyzer/dns_fcr.go
@ -24,7 +24,7 @@ package analyzer
 import (
 	"context"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // checkPTRAndForward performs reverse DNS lookup (PTR) and forward confirmation (A/AAAA)
@ -63,7 +63,7 @@ func (d *DNSAnalyzer) checkPTRAndForward(ip string) ([]string, []string) {
 }

 // Proper reverse DNS (PTR) and forward-confirmed reverse DNS (FCrDNS) is important for deliverability
-func (d *DNSAnalyzer) calculatePTRScore(results *model.DNSResults, senderIP string) (score int) {
+func (d *DNSAnalyzer) calculatePTRScore(results *api.DNSResults, senderIP string) (score int) {
 	if results.PtrRecords != nil && len(*results.PtrRecords) > 0 {
 		// 50 points for having PTR records
 		score += 50
--- a/pkg/analyzer/dns_mx.go
+++ b/pkg/analyzer/dns_mx.go
@ -25,37 +25,36 @@ import (
 	"context"
 	"fmt"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // checkMXRecords looks up MX records for a domain
-func (d *DNSAnalyzer) checkMXRecords(domain string) *[]model.MXRecord {
+func (d *DNSAnalyzer) checkMXRecords(domain string) *[]api.MXRecord {
 	ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
 	defer cancel()

 	mxRecords, err := d.resolver.LookupMX(ctx, domain)
 	if err != nil {
-		return &[]model.MXRecord{
+		return &[]api.MXRecord{
 			{
 				Valid: false,
-				Error: utils.PtrTo(fmt.Sprintf("Failed to lookup MX records: %v", err)),
+				Error: api.PtrTo(fmt.Sprintf("Failed to lookup MX records: %v", err)),
 			},
 		}
 	}

 	if len(mxRecords) == 0 {
-		return &[]model.MXRecord{
+		return &[]api.MXRecord{
 			{
 				Valid: false,
-				Error: utils.PtrTo("No MX records found"),
+				Error: api.PtrTo("No MX records found"),
 			},
 		}
 	}

-	var results []model.MXRecord
+	var results []api.MXRecord
 	for _, mx := range mxRecords {
-		results = append(results, model.MXRecord{
+		results = append(results, api.MXRecord{
 			Host:     mx.Host,
 			Priority: mx.Pref,
 			Valid:    true,
@ -65,7 +64,7 @@ func (d *DNSAnalyzer) checkMXRecords(domain string) *[]model.MXRecord {
 	return &results
 }

-func (d *DNSAnalyzer) calculateMXScore(results *model.DNSResults) (score int) {
+func (d *DNSAnalyzer) calculateMXScore(results *api.DNSResults) (score int) {
 	// Having valid MX records is critical for email deliverability
 	// From domain MX records (half points) - needed for replies
 	if results.FromMxRecords != nil && len(*results.FromMxRecords) > 0 {
--- a/pkg/analyzer/dns_spf.go
+++ b/pkg/analyzer/dns_spf.go
@ -27,34 +27,33 @@ import (
 	"regexp"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // checkSPFRecords looks up and validates SPF records for a domain, including resolving include: directives
-func (d *DNSAnalyzer) checkSPFRecords(domain string) *[]model.SPFRecord {
+func (d *DNSAnalyzer) checkSPFRecords(domain string) *[]api.SPFRecord {
 	visited := make(map[string]bool)
 	return d.resolveSPFRecords(domain, visited, 0, true)
 }

 // resolveSPFRecords recursively resolves SPF records including include: directives
 // isMainRecord indicates if this is the primary domain's record (not an included one)
-func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool, depth int, isMainRecord bool) *[]model.SPFRecord {
+func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool, depth int, isMainRecord bool) *[]api.SPFRecord {
 	const maxDepth = 10 // Prevent infinite recursion

 	if depth > maxDepth {
-		return &[]model.SPFRecord{
+		return &[]api.SPFRecord{
 			{
 				Domain: &domain,
 				Valid:  false,
-				Error:  utils.PtrTo("Maximum SPF include depth exceeded"),
+				Error:  api.PtrTo("Maximum SPF include depth exceeded"),
 			},
 		}
 	}

 	// Prevent circular references
 	if visited[domain] {
-		return &[]model.SPFRecord{}
+		return &[]api.SPFRecord{}
 	}
 	visited[domain] = true

@ -63,11 +62,11 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,

 	txtRecords, err := d.resolver.LookupTXT(ctx, domain)
 	if err != nil {
-		return &[]model.SPFRecord{
+		return &[]api.SPFRecord{
 			{
 				Domain: &domain,
 				Valid:  false,
-				Error:  utils.PtrTo(fmt.Sprintf("Failed to lookup TXT records: %v", err)),
+				Error:  api.PtrTo(fmt.Sprintf("Failed to lookup TXT records: %v", err)),
 			},
 		}
 	}
@ -83,23 +82,23 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,
 	}

 	if spfCount == 0 {
-		return &[]model.SPFRecord{
+		return &[]api.SPFRecord{
 			{
 				Domain: &domain,
 				Valid:  false,
-				Error:  utils.PtrTo("No SPF record found"),
+				Error:  api.PtrTo("No SPF record found"),
 			},
 		}
 	}

-	var results []model.SPFRecord
+	var results []api.SPFRecord

 	if spfCount > 1 {
-		results = append(results, model.SPFRecord{
+		results = append(results, api.SPFRecord{
 			Domain: &domain,
 			Record: &spfRecord,
 			Valid:  false,
-			Error:  utils.PtrTo("Multiple SPF records found (RFC violation)"),
+			Error:  api.PtrTo("Multiple SPF records found (RFC violation)"),
 		})
 		return &results
 	}
@ -108,28 +107,28 @@ func (d *DNSAnalyzer) resolveSPFRecords(domain string, visited map[string]bool,
 	validationErr := d.validateSPF(spfRecord, isMainRecord)

 	// Extract the "all" mechanism qualifier
-	var allQualifier *model.SPFRecordAllQualifier
+	var allQualifier *api.SPFRecordAllQualifier
 	var errMsg *string

 	if validationErr != nil {
-		errMsg = utils.PtrTo(validationErr.Error())
+		errMsg = api.PtrTo(validationErr.Error())
 	} else {
 		// Extract qualifier from the "all" mechanism
 		if strings.HasSuffix(spfRecord, " -all") {
-			allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("-"))
+			allQualifier = api.PtrTo(api.SPFRecordAllQualifier("-"))
 		} else if strings.HasSuffix(spfRecord, " ~all") {
-			allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("~"))
+			allQualifier = api.PtrTo(api.SPFRecordAllQualifier("~"))
 		} else if strings.HasSuffix(spfRecord, " +all") {
-			allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("+"))
+			allQualifier = api.PtrTo(api.SPFRecordAllQualifier("+"))
 		} else if strings.HasSuffix(spfRecord, " ?all") {
-			allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("?"))
+			allQualifier = api.PtrTo(api.SPFRecordAllQualifier("?"))
 		} else if strings.HasSuffix(spfRecord, " all") {
 			// Implicit + qualifier (default)
-			allQualifier = utils.PtrTo(model.SPFRecordAllQualifier("+"))
+			allQualifier = api.PtrTo(api.SPFRecordAllQualifier("+"))
 		}
 	}

-	results = append(results, model.SPFRecord{
+	results = append(results, api.SPFRecord{
 		Domain:       &domain,
 		Record:       &spfRecord,
 		Valid:        validationErr == nil,
@ -302,7 +301,7 @@ func (d *DNSAnalyzer) hasSPFStrictFail(record string) bool {
 	return strings.HasSuffix(record, " -all")
 }

-func (d *DNSAnalyzer) calculateSPFScore(results *model.DNSResults) (score int) {
+func (d *DNSAnalyzer) calculateSPFScore(results *api.DNSResults) (score int) {
 	// SPF is essential for email authentication
 	if results.SpfRecords != nil && len(*results.SpfRecords) > 0 {
 		// Find the main SPF record by skipping redirects
--- a/pkg/analyzer/headers.go
+++ b/pkg/analyzer/headers.go
@ -31,8 +31,7 @@ import (

 	"golang.org/x/net/publicsuffix"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // HeaderAnalyzer analyzes email header quality and structure
@ -44,7 +43,7 @@ func NewHeaderAnalyzer() *HeaderAnalyzer {
 }

 // CalculateHeaderScore evaluates email structural quality from header analysis
-func (h *HeaderAnalyzer) CalculateHeaderScore(analysis *model.HeaderAnalysis) (int, rune) {
+func (h *HeaderAnalyzer) CalculateHeaderScore(analysis *api.HeaderAnalysis) (int, rune) {
 	if analysis == nil || analysis.Headers == nil {
 		return 0, ' '
 	}
@ -188,7 +187,7 @@ func (h *HeaderAnalyzer) parseEmailDate(dateStr string) (time.Time, error) {
 }

 // isNoReplyAddress checks if a header check represents a no-reply email address
-func (h *HeaderAnalyzer) isNoReplyAddress(headerCheck model.HeaderCheck) bool {
+func (h *HeaderAnalyzer) isNoReplyAddress(headerCheck api.HeaderCheck) bool {
 	if !headerCheck.Present || headerCheck.Value == nil {
 		return false
 	}
@ -244,18 +243,18 @@ func (h *HeaderAnalyzer) formatAddress(addr *mail.Address) string {
 }

 // GenerateHeaderAnalysis creates structured header analysis from email
-func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults *model.AuthenticationResults) *model.HeaderAnalysis {
+func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults *api.AuthenticationResults) *api.HeaderAnalysis {
 	if email == nil {
 		return nil
 	}

-	analysis := &model.HeaderAnalysis{}
+	analysis := &api.HeaderAnalysis{}

 	// Check for proper MIME structure
-	analysis.HasMimeStructure = utils.PtrTo(len(email.Parts) > 0)
+	analysis.HasMimeStructure = api.PtrTo(len(email.Parts) > 0)

 	// Initialize headers map
-	headers := make(map[string]model.HeaderCheck)
+	headers := make(map[string]api.HeaderCheck)

 	// Check required headers
 	requiredHeaders := []string{"From", "To", "Date", "Message-ID", "Subject"}
@ -309,12 +308,12 @@ func (h *HeaderAnalyzer) GenerateHeaderAnalysis(email *EmailMessage, authResults
 }

 // checkHeader checks if a header is present and valid
-func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, importance string) *model.HeaderCheck {
+func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, importance string) *api.HeaderCheck {
 	value := email.GetHeaderValue(headerName)
 	present := email.HasHeader(headerName) && value != ""

-	importanceEnum := model.HeaderCheckImportance(importance)
-	check := &model.HeaderCheck{
+	importanceEnum := api.HeaderCheckImportance(importance)
+	check := &api.HeaderCheck{
 		Present:    present,
 		Importance: &importanceEnum,
 	}
@ -375,10 +374,10 @@ func (h *HeaderAnalyzer) checkHeader(email *EmailMessage, headerName string, imp
 }

 // analyzeDomainAlignment checks domain alignment between headers and DKIM signatures
-func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults *model.AuthenticationResults) *model.DomainAlignment {
-	alignment := &model.DomainAlignment{
-		Aligned:        utils.PtrTo(true),
-		RelaxedAligned: utils.PtrTo(true),
+func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults *api.AuthenticationResults) *api.DomainAlignment {
+	alignment := &api.DomainAlignment{
+		Aligned:        api.PtrTo(true),
+		RelaxedAligned: api.PtrTo(true),
 	}

 	// Extract From domain
@ -406,13 +405,13 @@ func (h *HeaderAnalyzer) analyzeDomainAlignment(email *EmailMessage, authResults
 	}

 	// Extract DKIM domains from authentication results
-	var dkimDomains []model.DKIMDomainInfo
+	var dkimDomains []api.DKIMDomainInfo
 	if authResults != nil && authResults.Dkim != nil {
 		for _, dkim := range *authResults.Dkim {
 			if dkim.Domain != nil && *dkim.Domain != "" {
 				domain := *dkim.Domain
 				orgDomain := h.getOrganizationalDomain(domain)
-				dkimDomains = append(dkimDomains, model.DKIMDomainInfo{
+				dkimDomains = append(dkimDomains, api.DKIMDomainInfo{
 					Domain:    domain,
 					OrgDomain: orgDomain,
 				})
@ -561,18 +560,18 @@ func (h *HeaderAnalyzer) getOrganizationalDomain(domain string) string {
 }

 // findHeaderIssues identifies issues with headers
-func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []model.HeaderIssue {
-	var issues []model.HeaderIssue
+func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []api.HeaderIssue {
+	var issues []api.HeaderIssue

 	// Check for missing required headers
 	requiredHeaders := []string{"From", "Date", "Message-ID"}
 	for _, header := range requiredHeaders {
 		if !email.HasHeader(header) || email.GetHeaderValue(header) == "" {
-			issues = append(issues, model.HeaderIssue{
+			issues = append(issues, api.HeaderIssue{
 				Header:   header,
-				Severity: model.HeaderIssueSeverityCritical,
+				Severity: api.HeaderIssueSeverityCritical,
 				Message:  fmt.Sprintf("Required header '%s' is missing", header),
-				Advice:   utils.PtrTo(fmt.Sprintf("Add the %s header to ensure RFC 5322 compliance", header)),
+				Advice:   api.PtrTo(fmt.Sprintf("Add the %s header to ensure RFC 5322 compliance", header)),
 			})
 		}
 	}
@ -580,11 +579,11 @@ func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []model.HeaderIss
 	// Check Message-ID format
 	messageID := email.GetHeaderValue("Message-ID")
 	if messageID != "" && !h.isValidMessageID(messageID) {
-		issues = append(issues, model.HeaderIssue{
+		issues = append(issues, api.HeaderIssue{
 			Header:   "Message-ID",
-			Severity: model.HeaderIssueSeverityMedium,
+			Severity: api.HeaderIssueSeverityMedium,
 			Message:  "Message-ID format is invalid",
-			Advice:   utils.PtrTo("Use proper Message-ID format: <unique-id@domain.com>"),
+			Advice:   api.PtrTo("Use proper Message-ID format: <unique-id@domain.com>"),
 		})
 	}

@ -592,7 +591,7 @@ func (h *HeaderAnalyzer) findHeaderIssues(email *EmailMessage) []model.HeaderIss
 }

 // parseReceivedChain extracts the chain of Received headers from an email
-func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []model.ReceivedHop {
+func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []api.ReceivedHop {
 	if email == nil || email.Header == nil {
 		return nil
 	}
@ -602,7 +601,7 @@ func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []model.Receive
 		return nil
 	}

-	var chain []model.ReceivedHop
+	var chain []api.ReceivedHop

 	for _, receivedValue := range receivedHeaders {
 		hop := h.parseReceivedHeader(receivedValue)
@ -615,8 +614,8 @@ func (h *HeaderAnalyzer) parseReceivedChain(email *EmailMessage) []model.Receive
 }

 // parseReceivedHeader parses a single Received header value
-func (h *HeaderAnalyzer) parseReceivedHeader(receivedValue string) *model.ReceivedHop {
-	hop := &model.ReceivedHop{}
+func (h *HeaderAnalyzer) parseReceivedHeader(receivedValue string) *api.ReceivedHop {
+	hop := &api.ReceivedHop{}

 	// Normalize whitespace - Received headers can span multiple lines
 	normalized := strings.Join(strings.Fields(receivedValue), " ")
--- a/pkg/analyzer/headers_test.go
+++ b/pkg/analyzer/headers_test.go
@ -27,7 +27,7 @@ import (
 	"strings"
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestCalculateHeaderScore(t *testing.T) {
@ -404,7 +404,7 @@ func TestParseReceivedChain(t *testing.T) {
 		name            string
 		receivedHeaders []string
 		expectedHops    int
-		validateFirst   func(*testing.T, *EmailMessage, []model.ReceivedHop)
+		validateFirst   func(*testing.T, *EmailMessage, []api.ReceivedHop)
 	}{
 		{
 			name:            "No Received headers",
@ -417,7 +417,7 @@ func TestParseReceivedChain(t *testing.T) {
 				"from mail.example.com (mail.example.com [192.0.2.1]) by mx.receiver.com (Postfix) with ESMTPS id ABC123 for <user@receiver.com>; Mon, 01 Jan 2024 12:00:00 +0000",
 			},
 			expectedHops: 1,
-			validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
+			validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) {
 				if len(hops) == 0 {
 					t.Fatal("Expected at least one hop")
 				}
@ -450,7 +450,7 @@ func TestParseReceivedChain(t *testing.T) {
 				"from mail2.example.com (mail2.example.com [192.0.2.2]) by mx2.receiver.com with SMTP id 222; Mon, 01 Jan 2024 11:59:00 +0000",
 			},
 			expectedHops: 2,
-			validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
+			validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) {
 				if len(hops) != 2 {
 					t.Fatalf("Expected 2 hops, got %d", len(hops))
 				}
@ -472,7 +472,7 @@ func TestParseReceivedChain(t *testing.T) {
 				"from mail.example.com (unknown [IPv6:2607:5300:203:2818::1]) by mx.receiver.com with ESMTPS; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)",
 			},
 			expectedHops: 1,
-			validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
+			validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) {
 				if len(hops) == 0 {
 					t.Fatal("Expected at least one hop")
 				}
@ -499,7 +499,7 @@ func TestParseReceivedChain(t *testing.T) {
 	for <test-9a9ce364-c394-4fa9-acef-d46ff2f482bf@deliver.happydomain.org>; Sun, 19 Oct 2025 09:40:33 +0000 (UTC)`,
 			},
 			expectedHops: 1,
-			validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
+			validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) {
 				if len(hops) == 0 {
 					t.Fatal("Expected at least one hop")
 				}
@ -527,7 +527,7 @@ func TestParseReceivedChain(t *testing.T) {
 				"from unknown by localhost",
 			},
 			expectedHops: 1,
-			validateFirst: func(t *testing.T, email *EmailMessage, hops []model.ReceivedHop) {
+			validateFirst: func(t *testing.T, email *EmailMessage, hops []api.ReceivedHop) {
 				if len(hops) == 0 {
 					t.Fatal("Expected at least one hop")
 				}
@ -1012,16 +1012,16 @@ func TestAnalyzeDomainAlignment_WithDKIM(t *testing.T) {
 			}

 			// Create authentication results with DKIM signatures
-			var authResults *model.AuthenticationResults
+			var authResults *api.AuthenticationResults
 			if len(tt.dkimDomains) > 0 {
-				dkimResults := make([]model.AuthResult, 0, len(tt.dkimDomains))
+				dkimResults := make([]api.AuthResult, 0, len(tt.dkimDomains))
 				for _, domain := range tt.dkimDomains {
-					dkimResults = append(dkimResults, model.AuthResult{
-						Result: model.AuthResultResultPass,
+					dkimResults = append(dkimResults, api.AuthResult{
+						Result: api.AuthResultResultPass,
 						Domain: &domain,
 					})
 				}
-				authResults = &model.AuthenticationResults{
+				authResults = &api.AuthenticationResults{
 					Dkim: &dkimResults,
 				}
 			}
--- a/pkg/analyzer/rbl.go
+++ b/pkg/analyzer/rbl.go
@ -30,8 +30,7 @@ import (
 	"sync"
 	"time"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // DNSListChecker checks IP addresses against DNS-based block/allow lists.
@ -118,7 +117,7 @@ func NewDNSWLChecker(timeout time.Duration, dnswls []string, checkAllIPs bool) *

 // DNSListResults represents the results of DNS list checks
 type DNSListResults struct {
-	Checks              map[string][]model.BlacklistCheck // Map of IP -> list of checks for that IP
+	Checks              map[string][]api.BlacklistCheck // Map of IP -> list of checks for that IP
 	IPsChecked          []string
 	ListedCount         int // Total listings including informational entries
 	RelevantListedCount int // Listings on scoring (non-informational) lists only
@ -127,7 +126,7 @@ type DNSListResults struct {
 // CheckEmail checks all IPs found in the email headers against the configured lists
 func (r *DNSListChecker) CheckEmail(email *EmailMessage) *DNSListResults {
 	results := &DNSListResults{
-		Checks: make(map[string][]model.BlacklistCheck),
+		Checks: make(map[string][]api.BlacklistCheck),
 	}

 	ips := r.extractIPs(email)
@ -158,12 +157,12 @@ func (r *DNSListChecker) CheckEmail(email *EmailMessage) *DNSListResults {
 }

 // CheckIP checks a single IP address against all configured lists in parallel
-func (r *DNSListChecker) CheckIP(ip string) ([]model.BlacklistCheck, int, error) {
+func (r *DNSListChecker) CheckIP(ip string) ([]api.BlacklistCheck, int, error) {
 	if !r.isPublicIP(ip) {
 		return nil, 0, fmt.Errorf("invalid or non-public IP address: %s", ip)
 	}

-	checks := make([]model.BlacklistCheck, len(r.Lists))
+	checks := make([]api.BlacklistCheck, len(r.Lists))
 	var wg sync.WaitGroup

 	for i, list := range r.Lists {
@ -240,14 +239,14 @@ func (r *DNSListChecker) isPublicIP(ipStr string) bool {
 }

 // checkIP checks a single IP against a single DNS list
-func (r *DNSListChecker) checkIP(ip, list string) model.BlacklistCheck {
-	check := model.BlacklistCheck{
+func (r *DNSListChecker) checkIP(ip, list string) api.BlacklistCheck {
+	check := api.BlacklistCheck{
 		Rbl: list,
 	}

 	reversedIP := r.reverseIP(ip)
 	if reversedIP == "" {
-		check.Error = utils.PtrTo("Failed to reverse IP address")
+		check.Error = api.PtrTo("Failed to reverse IP address")
 		return check
 	}

@ -264,17 +263,17 @@ func (r *DNSListChecker) checkIP(ip, list string) model.BlacklistCheck {
 				return check
 			}
 		}
-		check.Error = utils.PtrTo(fmt.Sprintf("DNS lookup failed: %v", err))
+		check.Error = api.PtrTo(fmt.Sprintf("DNS lookup failed: %v", err))
 		return check
 	}

 	if len(addrs) > 0 {
-		check.Response = utils.PtrTo(addrs[0])
+		check.Response = api.PtrTo(addrs[0])

 		// In RBL mode, 127.255.255.253/254/255 indicate operational errors, not real listings.
 		if r.filterErrorCodes && (addrs[0] == "127.255.255.253" || addrs[0] == "127.255.255.254" || addrs[0] == "127.255.255.255") {
 			check.Listed = false
-			check.Error = utils.PtrTo(fmt.Sprintf("RBL %s returned error code %s (RBL operational issue)", list, addrs[0]))
+			check.Error = api.PtrTo(fmt.Sprintf("RBL %s returned error code %s (RBL operational issue)", list, addrs[0]))
 		} else {
 			check.Listed = true
 		}
--- a/pkg/analyzer/rbl_test.go
+++ b/pkg/analyzer/rbl_test.go
@ -26,7 +26,7 @@ import (
 	"testing"
 	"time"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestNewRBLChecker(t *testing.T) {
@ -336,7 +336,7 @@ func TestGetBlacklistScore(t *testing.T) {

 func TestGetUniqueListedIPs(t *testing.T) {
 	results := &DNSListResults{
-		Checks: map[string][]model.BlacklistCheck{
+		Checks: map[string][]api.BlacklistCheck{
 			"198.51.100.1": {
 				{Rbl: "zen.spamhaus.org", Listed: true},
 				{Rbl: "bl.spamcop.net", Listed: true},
@ -364,7 +364,7 @@ func TestGetUniqueListedIPs(t *testing.T) {

 func TestGetRBLsForIP(t *testing.T) {
 	results := &DNSListResults{
-		Checks: map[string][]model.BlacklistCheck{
+		Checks: map[string][]api.BlacklistCheck{
 			"198.51.100.1": {
 				{Rbl: "zen.spamhaus.org", Listed: true},
 				{Rbl: "bl.spamcop.net", Listed: true},
--- a/pkg/analyzer/report.go
+++ b/pkg/analyzer/report.go
@ -24,7 +24,7 @@ package analyzer
 import (
 	"time"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 	"git.happydns.org/happyDeliver/internal/utils"
 	"github.com/google/uuid"
 )
@ -66,14 +66,14 @@ func NewReportGenerator(
 // AnalysisResults contains all intermediate analysis results
 type AnalysisResults struct {
 	Email          *EmailMessage
-	Authentication *model.AuthenticationResults
+	Authentication *api.AuthenticationResults
 	Content        *ContentResults
-	DNS            *model.DNSResults
-	Headers        *model.HeaderAnalysis
+	DNS            *api.DNSResults
+	Headers        *api.HeaderAnalysis
 	RBL            *DNSListResults
 	DNSWL          *DNSListResults
-	SpamAssassin   *model.SpamAssassinResult
-	Rspamd         *model.RspamdResult
+	SpamAssassin   *api.SpamAssassinResult
+	Rspamd         *api.RspamdResult
 }

 // AnalyzeEmail performs complete email analysis
@ -96,11 +96,11 @@ func (r *ReportGenerator) AnalyzeEmail(email *EmailMessage) *AnalysisResults {
 }

 // GenerateReport creates a complete API report from analysis results
-func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResults) *model.Report {
+func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResults) *api.Report {
 	reportID := uuid.New()
 	now := time.Now()

-	report := &model.Report{
+	report := &api.Report{
 		Id:        utils.UUIDToBase32(reportID),
 		TestId:    utils.UUIDToBase32(testID),
 		CreatedAt: now,
@ -169,19 +169,19 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
 		spamGrade = MinGrade(saGrade, rspamdGrade)
 	}

-	report.Summary = &model.ScoreSummary{
+	report.Summary = &api.ScoreSummary{
 		DnsScore:            dnsScore,
-		DnsGrade:            model.ScoreSummaryDnsGrade(dnsGrade),
+		DnsGrade:            api.ScoreSummaryDnsGrade(dnsGrade),
 		AuthenticationScore: authScore,
-		AuthenticationGrade: model.ScoreSummaryAuthenticationGrade(authGrade),
+		AuthenticationGrade: api.ScoreSummaryAuthenticationGrade(authGrade),
 		BlacklistScore:      blacklistScore,
-		BlacklistGrade:      model.ScoreSummaryBlacklistGrade(MinGrade(blacklistGrade, whitelistGrade)),
+		BlacklistGrade:      api.ScoreSummaryBlacklistGrade(MinGrade(blacklistGrade, whitelistGrade)),
 		ContentScore:        contentScore,
-		ContentGrade:        model.ScoreSummaryContentGrade(contentGrade),
+		ContentGrade:        api.ScoreSummaryContentGrade(contentGrade),
 		HeaderScore:         headerScore,
-		HeaderGrade:         model.ScoreSummaryHeaderGrade(headerGrade),
+		HeaderGrade:         api.ScoreSummaryHeaderGrade(headerGrade),
 		SpamScore:           spamScore,
-		SpamGrade:           model.ScoreSummarySpamGrade(spamGrade),
+		SpamGrade:           api.ScoreSummarySpamGrade(spamGrade),
 	}

 	// Add authentication results
@ -213,16 +213,16 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu

 	// Add SpamAssassin result with individual deliverability score
 	if results.SpamAssassin != nil {
-		saGradeTyped := model.SpamAssassinResultDeliverabilityGrade(saGrade)
-		results.SpamAssassin.DeliverabilityScore = utils.PtrTo(saScore)
+		saGradeTyped := api.SpamAssassinResultDeliverabilityGrade(saGrade)
+		results.SpamAssassin.DeliverabilityScore = api.PtrTo(saScore)
 		results.SpamAssassin.DeliverabilityGrade = &saGradeTyped
 	}
 	report.Spamassassin = results.SpamAssassin

 	// Add rspamd result with individual deliverability score
 	if results.Rspamd != nil {
-		rspamdGradeTyped := model.RspamdResultDeliverabilityGrade(rspamdGrade)
-		results.Rspamd.DeliverabilityScore = utils.PtrTo(rspamdScore)
+		rspamdGradeTyped := api.RspamdResultDeliverabilityGrade(rspamdGrade)
+		results.Rspamd.DeliverabilityScore = api.PtrTo(rspamdScore)
 		results.Rspamd.DeliverabilityGrade = &rspamdGradeTyped
 	}
 	report.Rspamd = results.Rspamd
@ -288,7 +288,7 @@ func (r *ReportGenerator) GenerateReport(testID uuid.UUID, results *AnalysisResu
 		}

 		if minusGrade < 255 {
-			report.Grade = model.ReportGrade(string([]byte{'A' + minusGrade}))
+			report.Grade = api.ReportGrade(string([]byte{'A' + minusGrade}))
 		}
 	}

--- a/pkg/analyzer/rspamd.go
+++ b/pkg/analyzer/rspamd.go
@ -27,7 +27,7 @@ import (
 	"strconv"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // Default rspamd action thresholds (rspamd built-in defaults)
@ -47,7 +47,7 @@ func NewRspamdAnalyzer(symbols map[string]string) *RspamdAnalyzer {
 }

 // AnalyzeRspamd extracts and analyzes rspamd results from email headers
-func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *model.RspamdResult {
+func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *api.RspamdResult {
 	headers := email.GetRspamdHeaders()
 	if len(headers) == 0 {
 		return nil
@ -60,8 +60,8 @@ func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *model.RspamdResult
 		return nil
 	}

-	result := &model.RspamdResult{
-		Symbols: make(map[string]model.SpamTestDetail),
+	result := &api.RspamdResult{
+		Symbols: make(map[string]api.SpamTestDetail),
 	}

 	// Parse X-Spamd-Result header (primary source for score, threshold, and symbols)
@ -107,7 +107,7 @@ func (a *RspamdAnalyzer) AnalyzeRspamd(email *EmailMessage) *model.RspamdResult

 // parseSpamdResult parses the X-Spamd-Result header
 // Format: "default: False [-3.91 / 15.00];\n\tSYMBOL(score)[params]; ..."
-func (a *RspamdAnalyzer) parseSpamdResult(header string, result *model.RspamdResult) {
+func (a *RspamdAnalyzer) parseSpamdResult(header string, result *api.RspamdResult) {
 	// Extract score and threshold from the first line
 	// e.g. "default: False [-3.91 / 15.00]"
 	scoreRe := regexp.MustCompile(`\[\s*(-?\d+\.?\d*)\s*/\s*(-?\d+\.?\d*)\s*\]`)
@ -141,7 +141,7 @@ func (a *RspamdAnalyzer) parseSpamdResult(header string, result *model.RspamdRes
 		if len(matches) > 2 {
 			name := matches[1]
 			score, _ := strconv.ParseFloat(matches[2], 64)
-			sym := model.SpamTestDetail{
+			sym := api.SpamTestDetail{
 				Name:  name,
 				Score: float32(score),
 			}
@ -155,7 +155,7 @@ func (a *RspamdAnalyzer) parseSpamdResult(header string, result *model.RspamdRes
 }

 // CalculateRspamdScore calculates the rspamd contribution to deliverability (0-100 scale)
-func (a *RspamdAnalyzer) CalculateRspamdScore(result *model.RspamdResult) (int, string) {
+func (a *RspamdAnalyzer) CalculateRspamdScore(result *api.RspamdResult) (int, string) {
 	if result == nil {
 		return 100, "" // rspamd not installed
 	}
--- a/pkg/analyzer/rspamd_test.go
+++ b/pkg/analyzer/rspamd_test.go
@ -26,7 +26,7 @@ import (
 	"net/mail"
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestAnalyzeRspamdNoHeaders(t *testing.T) {
@ -130,8 +130,8 @@ func TestParseSpamdResult(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := &model.RspamdResult{
-				Symbols: make(map[string]model.SpamTestDetail),
+			result := &api.RspamdResult{
+				Symbols: make(map[string]api.SpamTestDetail),
 			}
 			analyzer.parseSpamdResult(tt.header, result)

@ -281,7 +281,7 @@ func TestAnalyzeRspamd(t *testing.T) {
 func TestCalculateRspamdScore(t *testing.T) {
 	tests := []struct {
 		name          string
-		result        *model.RspamdResult
+		result        *api.RspamdResult
 		expectedScore int
 		expectedGrade string
 	}{
@ -293,7 +293,7 @@ func TestCalculateRspamdScore(t *testing.T) {
 		},
 		{
 			name: "Score well below threshold",
-			result: &model.RspamdResult{
+			result: &api.RspamdResult{
 				Score:     -3.91,
 				Threshold: 15.00,
 			},
@ -302,7 +302,7 @@ func TestCalculateRspamdScore(t *testing.T) {
 		},
 		{
 			name: "Score at zero",
-			result: &model.RspamdResult{
+			result: &api.RspamdResult{
 				Score:     0,
 				Threshold: 15.00,
 			},
@ -312,7 +312,7 @@ func TestCalculateRspamdScore(t *testing.T) {
 		},
 		{
 			name: "Score at threshold (half of 2*threshold)",
-			result: &model.RspamdResult{
+			result: &api.RspamdResult{
 				Score:     15.00,
 				Threshold: 15.00,
 			},
@ -321,7 +321,7 @@ func TestCalculateRspamdScore(t *testing.T) {
 		},
 		{
 			name: "Score above 2*threshold",
-			result: &model.RspamdResult{
+			result: &api.RspamdResult{
 				Score:     31.00,
 				Threshold: 15.00,
 			},
@ -330,7 +330,7 @@ func TestCalculateRspamdScore(t *testing.T) {
 		},
 		{
 			name: "Score exactly at 2*threshold",
-			result: &model.RspamdResult{
+			result: &api.RspamdResult{
 				Score:     30.00,
 				Threshold: 15.00,
 			},
--- a/pkg/analyzer/scoring.go
+++ b/pkg/analyzer/scoring.go
@ -22,7 +22,7 @@
 package analyzer

 import (
-	"git.happydns.org/happyDeliver/internal/model"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // ScoreToGrade converts a percentage score (0-100) to a letter grade
@ -65,9 +65,9 @@ func ScoreToGradeKind(score int) string {
 	}
 }

-// ScoreToReportGrade converts a percentage score to an model.ReportGrade
-func ScoreToReportGrade(score int) model.ReportGrade {
-	return model.ReportGrade(ScoreToGrade(score))
+// ScoreToReportGrade converts a percentage score to an api.ReportGrade
+func ScoreToReportGrade(score int) api.ReportGrade {
+	return api.ReportGrade(ScoreToGrade(score))
 }

 // gradeRank returns a numeric rank for a grade (lower = worse)
--- a/pkg/analyzer/spamassassin.go
+++ b/pkg/analyzer/spamassassin.go
@ -27,8 +27,7 @@ import (
 	"strconv"
 	"strings"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 // SpamAssassinAnalyzer analyzes SpamAssassin results from email headers
@ -40,7 +39,7 @@ func NewSpamAssassinAnalyzer() *SpamAssassinAnalyzer {
 }

 // AnalyzeSpamAssassin extracts and analyzes SpamAssassin results from email headers
-func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *model.SpamAssassinResult {
+func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *api.SpamAssassinResult {
 	headers := email.GetSpamAssassinHeaders()
 	if len(headers) == 0 {
 		return nil
@ -54,8 +53,8 @@ func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *model.S
 		return nil
 	}

-	result := &model.SpamAssassinResult{
-		TestDetails: make(map[string]model.SpamTestDetail),
+	result := &api.SpamAssassinResult{
+		TestDetails: make(map[string]api.SpamTestDetail),
 	}

 	// Parse X-Spam-Status header
@ -77,13 +76,13 @@ func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *model.S

 	// Parse X-Spam-Report header for detailed test results
 	if reportHeader, ok := headers["X-Spam-Report"]; ok {
-		result.Report = utils.PtrTo(strings.Replace(reportHeader, " * ", "\n* ", -1))
+		result.Report = api.PtrTo(strings.Replace(reportHeader, " * ", "\n* ", -1))
 		a.parseSpamReport(reportHeader, result)
 	}

 	// Parse X-Spam-Checker-Version
 	if versionHeader, ok := headers["X-Spam-Checker-Version"]; ok {
-		result.Version = utils.PtrTo(strings.TrimSpace(versionHeader))
+		result.Version = api.PtrTo(strings.TrimSpace(versionHeader))
 	}

 	return result
@ -91,7 +90,7 @@ func (a *SpamAssassinAnalyzer) AnalyzeSpamAssassin(email *EmailMessage) *model.S

 // parseSpamStatus parses the X-Spam-Status header
 // Format: Yes/No, score=5.5 required=5.0 tests=TEST1,TEST2,TEST3 autolearn=no
-func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *model.SpamAssassinResult) {
+func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *api.SpamAssassinResult) {
 	// Check if spam (first word)
 	parts := strings.SplitN(header, ",", 2)
 	if len(parts) > 0 {
@ -135,7 +134,7 @@ func (a *SpamAssassinAnalyzer) parseSpamStatus(header string, result *model.Spam
 // *  0.0 TEST_NAME Description line 1
 // *      continuation line 2
 // *      continuation line 3
-func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.SpamAssassinResult) {
+func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *api.SpamAssassinResult) {
 	segments := strings.Split(report, "*")

 	// Regex to match test lines: score TEST_NAME Description
@ -157,7 +156,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.Spam
 			// Save previous test if exists
 			if currentTestName != "" {
 				description := strings.TrimSpace(currentDescription.String())
-				detail := model.SpamTestDetail{
+				detail := api.SpamTestDetail{
 					Name:        currentTestName,
 					Score:       result.TestDetails[currentTestName].Score,
 					Description: &description,
@ -175,7 +174,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.Spam
 			currentDescription.WriteString(description)

 			// Initialize with score
-			result.TestDetails[testName] = model.SpamTestDetail{
+			result.TestDetails[testName] = api.SpamTestDetail{
 				Name:  testName,
 				Score: float32(score),
 			}
@ -192,7 +191,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.Spam
 	// Save the last test if exists
 	if currentTestName != "" {
 		description := strings.TrimSpace(currentDescription.String())
-		detail := model.SpamTestDetail{
+		detail := api.SpamTestDetail{
 			Name:        currentTestName,
 			Score:       result.TestDetails[currentTestName].Score,
 			Description: &description,
@ -202,7 +201,7 @@ func (a *SpamAssassinAnalyzer) parseSpamReport(report string, result *model.Spam
 }

 // CalculateSpamAssassinScore calculates the SpamAssassin contribution to deliverability
-func (a *SpamAssassinAnalyzer) CalculateSpamAssassinScore(result *model.SpamAssassinResult) (int, string) {
+func (a *SpamAssassinAnalyzer) CalculateSpamAssassinScore(result *api.SpamAssassinResult) (int, string) {
 	if result == nil {
 		return 100, "" // No spam scan results, assume good
 	}
--- a/pkg/analyzer/spamassassin_test.go
+++ b/pkg/analyzer/spamassassin_test.go
@ -27,8 +27,7 @@ import (
 	"strings"
 	"testing"

-	"git.happydns.org/happyDeliver/internal/model"
-	"git.happydns.org/happyDeliver/internal/utils"
+	"git.happydns.org/happyDeliver/internal/api"
 )

 func TestParseSpamStatus(t *testing.T) {
@ -78,8 +77,8 @@ func TestParseSpamStatus(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := &model.SpamAssassinResult{
-				TestDetails: make(map[string]model.SpamTestDetail),
+			result := &api.SpamAssassinResult{
+				TestDetails: make(map[string]api.SpamTestDetail),
 			}
 			analyzer.parseSpamStatus(tt.header, result)

@ -116,27 +115,27 @@ func TestParseSpamReport(t *testing.T) {
 `

 	analyzer := NewSpamAssassinAnalyzer()
-	result := &model.SpamAssassinResult{
-		TestDetails: make(map[string]model.SpamTestDetail),
+	result := &api.SpamAssassinResult{
+		TestDetails: make(map[string]api.SpamTestDetail),
 	}

 	analyzer.parseSpamReport(report, result)

-	expectedTests := map[string]model.SpamTestDetail{
+	expectedTests := map[string]api.SpamTestDetail{
 		"BAYES_99": {
 			Name:        "BAYES_99",
 			Score:       5.0,
-			Description: utils.PtrTo("Bayes spam probability is 99 to 100%"),
+			Description: api.PtrTo("Bayes spam probability is 99 to 100%"),
 		},
 		"SPOOFED_SENDER": {
 			Name:        "SPOOFED_SENDER",
 			Score:       3.5,
-			Description: utils.PtrTo("From address doesn't match envelope sender"),
+			Description: api.PtrTo("From address doesn't match envelope sender"),
 		},
 		"ALL_TRUSTED": {
 			Name:        "ALL_TRUSTED",
 			Score:       -1.0,
-			Description: utils.PtrTo("All mail servers are trusted"),
+			Description: api.PtrTo("All mail servers are trusted"),
 		},
 	}

@ -158,7 +157,7 @@ func TestParseSpamReport(t *testing.T) {
 func TestGetSpamAssassinScore(t *testing.T) {
 	tests := []struct {
 		name          string
-		result        *model.SpamAssassinResult
+		result        *api.SpamAssassinResult
 		expectedScore int
 		minScore      int
 		maxScore      int
@ -170,7 +169,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "Excellent score (negative)",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         -2.5,
 				RequiredScore: 5.0,
 			},
@ -178,7 +177,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "Good score (below threshold)",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         2.0,
 				RequiredScore: 5.0,
 			},
@ -186,7 +185,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "Score at threshold",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         5.0,
 				RequiredScore: 5.0,
 			},
@ -194,7 +193,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "Above threshold (spam)",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         6.0,
 				RequiredScore: 5.0,
 			},
@ -202,7 +201,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "High spam score",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         12.0,
 				RequiredScore: 5.0,
 			},
@ -210,7 +209,7 @@ func TestGetSpamAssassinScore(t *testing.T) {
 		},
 		{
 			name: "Very high spam score",
-			result: &model.SpamAssassinResult{
+			result: &api.SpamAssassinResult{
 				Score:         20.0,
 				RequiredScore: 5.0,
 			},