diff --git a/docs/api-resources.md b/docs/api-resources.md
index 1304905e..9c8ddb82 100644
--- a/docs/api-resources.md
+++ b/docs/api-resources.md
@@ -685,8 +685,8 @@ All list endpoints accept the following query parameters:
 | Parameter  | Type           | Required | Default             | Constraints          |
 |------------|----------------|----------|---------------------|----------------------|
 | `search`   | string         | No       | -                   | TSL query syntax     |
-| `page`     | integer (int32)| No       | `1`                 | Must be >= 1         |
-| `size`     | integer (int32)| No       | `20`                | Must be between 1 and 100 |
+| `page`     | integer (int64)| No       | `1`                 | Must be >= 1         |
+| `size`     | integer (int64)| No       | `20`                | Must be between 1 and 100 |
 | `order`    | string         | No       | `created_time desc` | Field name(s) with optional direction (asc/desc) |
 
 **Ordering behavior**:
diff --git a/docs/development.md b/docs/development.md
index 7592e509..33ff4a51 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -306,7 +306,7 @@ Mock implementations of service interfaces are used for unit testing. Mocks are
 Service files contain `//go:generate` directives that specify how to generate mocks:
 
 ```go
-//go:generate mockgen-v0.6.0 -source=resource.go -package=services -destination=resource_mock.go
+//go:generate go tool -modfile=../../tools/go.mod mockgen -source=resource.go -package=services -destination=resource_mock.go
 ```
 
 **Commands**:
diff --git a/pkg/api/metadata_types.go b/pkg/api/metadata_types.go
index b862d133..1571a652 100755
--- a/pkg/api/metadata_types.go
+++ b/pkg/api/metadata_types.go
@@ -40,7 +40,7 @@ type Meta struct {
 
 // PagingMeta List Paging metadata
 type PagingMeta struct {
-	Page  int
+	Page  int64
 	Size  int64
 	Total int64
 }
diff --git a/pkg/handlers/framework.go b/pkg/handlers/framework.go
index e178ff57..c8539a4c 100755
--- a/pkg/handlers/framework.go
+++ b/pkg/handlers/framework.go
@@ -10,7 +10,6 @@ import (
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/api/response"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
-	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/services"
 )
 
 // handlerConfig defines the common things each REST controller must do.
@@ -59,7 +58,7 @@ func handleError(r *http.Request, w http.ResponseWriter, err *errors.ServiceErro
 // Note: This function only validates the fields parameter, not pagination parameters,
 // to avoid rejecting irrelevant query params on single-resource GET endpoints.
 func applyFieldFilter(r *http.Request, presented interface{}) (interface{}, *errors.ServiceError) {
-	fields := services.ParseFieldsParameter(r.URL.Query())
+	fields := ensureIDField(normalizeList(r.URL.Query()["fields"]))
 	if fields != nil {
 		filtered, filterErr := presenters.FilterSingle(fields, presented)
 		if filterErr != nil {
diff --git a/pkg/handlers/list_params.go b/pkg/handlers/list_params.go
new file mode 100644
index 00000000..5a75938b
--- /dev/null
+++ b/pkg/handlers/list_params.go
@@ -0,0 +1,174 @@
+package handlers
+
+import (
+	"net/url"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/go-playground/validator/v10"
+
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/services"
+)
+
+const defaultOrder = "created_time desc"
+
+type listParams struct {
+	RefType     string `validate:"required_with=RefTargetID"`
+	RefTargetID string `validate:"required_with=RefType"`
+	Size        int64  `validate:"min=1,max=100"`
+	Page        int64  `validate:"min=1,max=100000"`
+}
+
+var listParamsValidator = validator.New()
+
+func parseListParams(query url.Values) (*services.ListArguments, *errors.ServiceError) {
+	p, formatErr := bindListParams(query)
+	if formatErr != nil {
+		return nil, formatErr
+	}
+
+	if err := validateListParams(p); err != nil {
+		return nil, err
+	}
+
+	args := &services.ListArguments{
+		Page:        p.Page,
+		Size:        p.Size,
+		Search:      strings.TrimSpace(query.Get("search")),
+		RefType:     p.RefType,
+		RefTargetID: p.RefTargetID,
+		Fields:      ensureIDField(normalizeList(query["fields"])),
+		Order:       normalizeList(query["order"]),
+	}
+
+	if len(args.Order) == 0 {
+		args.Order = []string{defaultOrder}
+	}
+
+	return args, nil
+}
+
+func bindListParams(query url.Values) (*listParams, *errors.ServiceError) {
+	defaults := services.NewListArguments()
+	p := &listParams{
+		Page:        defaults.Page,
+		Size:        defaults.Size,
+		RefType:     strings.TrimSpace(query.Get("ref_type")),
+		RefTargetID: strings.TrimSpace(query.Get("ref_target_id")),
+	}
+
+	var formatErrors []errors.ValidationDetail
+
+	if v := strings.TrimSpace(query.Get("page")); v != "" {
+		page, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			formatErrors = append(formatErrors, errors.ValidationDetail{
+				Field:      "page",
+				Value:      v,
+				Constraint: "format",
+				Message:    "must be a valid integer",
+			})
+		} else {
+			p.Page = page
+		}
+	}
+
+	if v := strings.TrimSpace(query.Get("size")); v != "" {
+		size, err := strconv.ParseInt(v, 10, 64)
+		if err != nil {
+			formatErrors = append(formatErrors, errors.ValidationDetail{
+				Field:      "size",
+				Value:      v,
+				Constraint: "format",
+				Message:    "must be a valid integer",
+			})
+		} else {
+			p.Size = size
+		}
+	}
+
+	if len(formatErrors) > 0 {
+		return nil, errors.ValidationWithDetails("Invalid query parameters", formatErrors)
+	}
+
+	return p, nil
+}
+
+func validateListParams(p *listParams) *errors.ServiceError {
+	err := listParamsValidator.Struct(p)
+	if err == nil {
+		return nil
+	}
+
+	validationErrors, ok := err.(validator.ValidationErrors)
+	if !ok {
+		return errors.GeneralError("unexpected validation error: %s", err)
+	}
+
+	var details []errors.ValidationDetail
+	for _, fe := range validationErrors {
+		field := strings.ToLower(fe.Field())
+		details = append(details, errors.ValidationDetail{
+			Field:      field,
+			Value:      fe.Value(),
+			Constraint: mapConstraint(fe.Tag()),
+			Message:    validationMessage(field, fe),
+		})
+	}
+
+	return errors.ValidationWithDetails("Invalid query parameters", details)
+}
+
+func validationMessage(field string, fe validator.FieldError) string {
+	switch fe.Tag() {
+	case "min":
+		return field + " must be at least " + fe.Param()
+	case "max":
+		return field + " must be at most " + fe.Param()
+	case "required_with":
+		return "ref_type and ref_target_id must be provided together"
+	default:
+		return fe.Error()
+	}
+}
+
+func mapConstraint(tag string) string {
+	switch tag {
+	case "required_with":
+		return "required"
+	default:
+		return tag
+	}
+}
+
+func ensureIDField(fields []string) []string {
+	if len(fields) == 0 {
+		return nil
+	}
+	if slices.Contains(fields, "id") {
+		return fields
+	}
+	return append(fields, "id")
+}
+
+// normalizeList splits comma-separated values, trims whitespace, and drops empties.
+// Supports both ?key=a,b and ?key=a&key=b.
+func normalizeList(values []string) []string {
+	var result []string
+
+	for _, value := range values {
+		for _, item := range strings.Split(value, ",") {
+			if item = strings.TrimSpace(item); item != "" {
+				result = append(result, item)
+			}
+		}
+	}
+
+	if len(result) == 0 {
+		return nil
+	}
+
+	return result
+}
diff --git a/pkg/handlers/list_params_test.go b/pkg/handlers/list_params_test.go
new file mode 100644
index 00000000..49a138e4
--- /dev/null
+++ b/pkg/handlers/list_params_test.go
@@ -0,0 +1,379 @@
+package handlers
+
+import (
+	"net/url"
+	"testing"
+
+	. "github.com/onsi/gomega"
+
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/services"
+)
+
+func TestParseListParams(t *testing.T) {
+	RegisterTestingT(t)
+
+	tests := []struct {
+		name     string
+		query    string
+		expected *services.ListArguments
+		errors   []expectedDetail
+	}{
+		// Defaults
+		{
+			name:  "defaults",
+			query: "",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		// Custom values
+		{
+			name:  "custom page and size",
+			query: "?page=2&size=50",
+			expected: &services.ListArguments{
+				Page:  2,
+				Size:  50,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "search",
+			query: "?search=status%20%3D%20active",
+			expected: &services.ListArguments{
+				Page:   1,
+				Size:   20,
+				Search: "status = active",
+				Order:  []string{"created_time desc"},
+			},
+		},
+		// Order
+		{
+			name:  "custom order",
+			query: "?order=name%20asc,created_time%20desc",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"name asc", "created_time desc"},
+			},
+		},
+		{
+			name:  "order preserves raw value for downstream validation",
+			query: "?order=name%20%20%20asc",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"name   asc"},
+			},
+		},
+		// Fields
+		{
+			name:  "fields auto-includes id",
+			query: "?fields=name,kind",
+			expected: &services.ListArguments{
+				Page:   1,
+				Size:   20,
+				Order:  []string{"created_time desc"},
+				Fields: []string{"name", "kind", "id"},
+			},
+		},
+		{
+			name:  "fields preserves existing id",
+			query: "?fields=id,name",
+			expected: &services.ListArguments{
+				Page:   1,
+				Size:   20,
+				Order:  []string{"created_time desc"},
+				Fields: []string{"id", "name"},
+			},
+		},
+		// Ref pairing
+		{
+			name:  "paired ref parameters",
+			query: "?ref_type=dep&ref_target_id=target-1",
+			expected: &services.ListArguments{
+				Page:        1,
+				Size:        20,
+				Order:       []string{"created_time desc"},
+				RefType:     "dep",
+				RefTargetID: "target-1",
+			},
+		},
+		{
+			name:  "ref_type without target_id",
+			query: "?ref_type=dep",
+			errors: []expectedDetail{
+				{message: "ref_type and ref_target_id must be provided together"},
+			},
+		},
+		{
+			name:  "ref_target_id without ref_type",
+			query: "?ref_target_id=some-id",
+			errors: []expectedDetail{
+				{message: "ref_type and ref_target_id must be provided together"},
+			},
+		},
+		// Format errors
+		{
+			name:  "non-numeric page",
+			query: "?page=abc",
+			errors: []expectedDetail{
+				{field: "page", message: "must be a valid integer"},
+			},
+		},
+		{
+			name:  "non-numeric size",
+			query: "?size=xyz",
+			errors: []expectedDetail{
+				{field: "size", message: "must be a valid integer"},
+			},
+		},
+		{
+			name:  "both page and size non-numeric",
+			query: "?page=abc&size=xyz",
+			errors: []expectedDetail{
+				{field: "page", message: "must be a valid integer"},
+				{field: "size", message: "must be a valid integer"},
+			},
+		},
+		// Range errors
+		{
+			name:  "negative page",
+			query: "?page=-1",
+			errors: []expectedDetail{
+				{field: "page", message: "page must be at least 1"},
+			},
+		},
+		{
+			name:  "zero page",
+			query: "?page=0",
+			errors: []expectedDetail{
+				{field: "page", message: "page must be at least 1"},
+			},
+		},
+		{
+			name:  "negative size",
+			query: "?size=-1",
+			errors: []expectedDetail{
+				{field: "size", message: "size must be at least 1"},
+			},
+		},
+		{
+			name:  "zero size",
+			query: "?size=0",
+			errors: []expectedDetail{
+				{field: "size", message: "size must be at least 1"},
+			},
+		},
+		{
+			name:  "size above maximum",
+			query: "?size=101",
+			errors: []expectedDetail{
+				{field: "size", message: "size must be at most 100"},
+			},
+		},
+		{
+			name:  "very large size",
+			query: "?size=999999",
+			errors: []expectedDetail{
+				{field: "size", message: "size must be at most 100"},
+			},
+		},
+		{
+			name:  "multiple range errors at once",
+			query: "?page=0&size=999",
+			errors: []expectedDetail{
+				{field: "page", message: "page must be at least 1"},
+				{field: "size", message: "size must be at most 100"},
+			},
+		},
+		// Edge cases
+		{
+			name:  "search with leading and trailing spaces",
+			query: "?search=%20%20status%20%3D%20active%20%20",
+			expected: &services.ListArguments{
+				Page:   1,
+				Size:   20,
+				Search: "status = active",
+				Order:  []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "empty order falls back to default",
+			query: "?order=",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "whitespace-only order falls back to default",
+			query: "?order=%20%20%20",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "pageSize is ignored",
+			query: "?pageSize=50",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "valid boundary page=1 size=1",
+			query: "?page=1&size=1",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  1,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "valid boundary page=1 size=100",
+			query: "?page=1&size=100",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  100,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "valid large page",
+			query: "?page=999&size=50",
+			expected: &services.ListArguments{
+				Page:  999,
+				Size:  50,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "page above maximum",
+			query: "?page=100001",
+			errors: []expectedDetail{
+				{field: "page", message: "page must be at most 100000"},
+			},
+		},
+		// Invalid query fields
+		{
+			name:  "unknown query parameters are ignored",
+			query: "?foo=bar&baz=123",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "unknown parameters mixed with valid ones",
+			query: "?page=3&unknown=value&size=10",
+			expected: &services.ListArguments{
+				Page:  3,
+				Size:  10,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "float page",
+			query: "?page=1.5",
+			errors: []expectedDetail{
+				{field: "page", message: "must be a valid integer"},
+			},
+		},
+		{
+			name:  "float size",
+			query: "?size=10.5",
+			errors: []expectedDetail{
+				{field: "size", message: "must be a valid integer"},
+			},
+		},
+		{
+			name:  "special characters in size",
+			query: "?size=%21%40%23",
+			errors: []expectedDetail{
+				{field: "size", message: "must be a valid integer"},
+			},
+		},
+		{
+			name:  "empty fields value yields no field filtering",
+			query: "?fields=",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+		{
+			name:  "whitespace-only page falls back to default",
+			query: "?page=%20%20",
+			expected: &services.ListArguments{
+				Page:  1,
+				Size:  20,
+				Order: []string{"created_time desc"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			RegisterTestingT(t)
+			u, _ := url.Parse("/resources" + tt.query)
+			result, err := parseListParams(u.Query())
+
+			if len(tt.errors) > 0 {
+				Expect(err).ToNot(BeNil())
+				Expect(err.HTTPCode).To(Equal(400))
+				Expect(result).To(BeNil())
+				for _, exp := range tt.errors {
+					matcher := HaveField("Message", exp.message)
+					if exp.field != "" {
+						matcher = And(HaveField("Field", exp.field), matcher)
+					}
+					Expect(err.Details).To(ContainElement(matcher))
+				}
+			} else {
+				Expect(err).To(BeNil())
+				Expect(result).To(Equal(tt.expected))
+			}
+		})
+	}
+}
+
+type expectedDetail struct {
+	field   string
+	message string
+}
+
+func TestNormalizeList(t *testing.T) {
+	RegisterTestingT(t)
+
+	tests := []struct {
+		name     string
+		input    []string
+		expected []string
+	}{
+		{"nil input", nil, nil},
+		{"empty input", []string{}, nil},
+		{"single value", []string{"name"}, []string{"name"}},
+		{"comma-separated", []string{"name,kind,id"}, []string{"name", "kind", "id"}},
+		{"repeated params", []string{"name", "kind", "id"}, []string{"name", "kind", "id"}},
+		{"mixed", []string{"name,kind", "id"}, []string{"name", "kind", "id"}},
+		{"with whitespace", []string{" name , kind , id "}, []string{"name", "kind", "id"}},
+		{"trailing comma", []string{"name,"}, []string{"name"}},
+		{"only commas", []string{",,,"}, nil},
+		{"empty strings", []string{"", ""}, nil},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			RegisterTestingT(t)
+			Expect(normalizeList(tt.input)).To(Equal(tt.expected))
+		})
+	}
+}
diff --git a/pkg/handlers/resource_handler.go b/pkg/handlers/resource_handler.go
index 8d5f2b96..42d3c16b 100644
--- a/pkg/handlers/resource_handler.go
+++ b/pkg/handlers/resource_handler.go
@@ -109,7 +109,7 @@ func (h *ResourceHandler) List(w http.ResponseWriter, r *http.Request) {
 		Action: func() (interface{}, *errors.ServiceError) {
 			ctx := r.Context()
 
-			listArgs, err := services.NewListArguments(r.URL.Query())
+			listArgs, err := parseListParams(r.URL.Query())
 			if err != nil {
 				return nil, err
 			}
diff --git a/pkg/handlers/resource_status_handler.go b/pkg/handlers/resource_status_handler.go
index 156e36d8..5ef3ce2d 100644
--- a/pkg/handlers/resource_status_handler.go
+++ b/pkg/handlers/resource_status_handler.go
@@ -43,7 +43,7 @@ func (h *ResourceStatusHandler) List(w http.ResponseWriter, r *http.Request) {
 		Action: func() (interface{}, *errors.ServiceError) {
 			ctx := r.Context()
 			id := mux.Vars(r)["id"]
-			listArgs, err := services.NewListArguments(r.URL.Query())
+			listArgs, err := parseListParams(r.URL.Query())
 			if err != nil {
 				return nil, err
 			}
diff --git a/pkg/handlers/root_resource_handler.go b/pkg/handlers/root_resource_handler.go
index 7ec7c07b..26ce6afd 100644
--- a/pkg/handlers/root_resource_handler.go
+++ b/pkg/handlers/root_resource_handler.go
@@ -36,7 +36,7 @@ func NewRootResourceHandler(
 func (h *RootResourceHandler) List(w http.ResponseWriter, r *http.Request) {
 	cfg := &handlerConfig{
 		Action: func() (interface{}, *errors.ServiceError) {
-			listArgs, err := services.NewListArguments(r.URL.Query())
+			listArgs, err := parseListParams(r.URL.Query())
 			if err != nil {
 				return nil, err
 			}
@@ -206,7 +206,7 @@ func (h *RootResourceHandler) ListStatuses(w http.ResponseWriter, r *http.Reques
 		Action: func() (interface{}, *errors.ServiceError) {
 			ctx := r.Context()
 			id := mux.Vars(r)["id"]
-			listArgs, err := services.NewListArguments(r.URL.Query())
+			listArgs, err := parseListParams(r.URL.Query())
 			if err != nil {
 				return nil, err
 			}
diff --git a/pkg/services/adapter_status.go b/pkg/services/adapter_status.go
index 85ad10d5..8304a223 100644
--- a/pkg/services/adapter_status.go
+++ b/pkg/services/adapter_status.go
@@ -81,7 +81,7 @@ func (s *sqlAdapterStatusService) FindByResource(
 func (s *sqlAdapterStatusService) FindByResourcePaginated(
 	ctx context.Context, resourceType, resourceID string, listArgs *ListArguments,
 ) (api.AdapterStatusList, int64, *errors.ServiceError) {
-	offset := (listArgs.Page - 1) * int(listArgs.Size)
+	offset := int((listArgs.Page - 1) * listArgs.Size)
 	limit := int(listArgs.Size)
 
 	statuses, total, err := s.adapterStatusDao.FindByResourcePaginated(ctx, resourceType, resourceID, offset, limit)
diff --git a/pkg/services/generic.go b/pkg/services/generic.go
index 9b009db0..301836e2 100755
--- a/pkg/services/generic.go
+++ b/pkg/services/generic.go
@@ -17,7 +17,6 @@ import (
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/dao"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/db"
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
-	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/logger"
 )
 
 //go:generate go tool -modfile=../../tools/go.mod mockgen -source=generic.go -package=services -destination=generic_mock.go
@@ -61,7 +60,6 @@ func (s *sqlGenericService) newListContext(
 	if resourceTypeStr == "" {
 		return nil, nil, errors.GeneralError("Could not determine resource type")
 	}
-	args.Search = strings.Trim(args.Search, " ")
 	return &listContext{
 		ctx:          ctx,
 		args:         args,
@@ -100,11 +98,11 @@ func (s *sqlGenericService) List(
 	// it stops when a builder function raises error or signals finished.
 	var finished bool
 	for _, builderFn := range builders {
-		if finished, err = builderFn(listCtx, &d); err != nil {
+		if finished, err = builderFn(listCtx, d); err != nil {
 			return nil, err
 		}
 		if finished {
-			if err = s.loadList(listCtx, &d); err != nil {
+			if err = s.loadList(listCtx, d); err != nil {
 				return nil, err
 			}
 			break
@@ -114,9 +112,9 @@ func (s *sqlGenericService) List(
 }
 
 /*** Define all sub functions in the type of listBuilder ***/
-type listBuilder func(*listContext, *dao.GenericDao) (finished bool, err *errors.ServiceError)
+type listBuilder func(*listContext, dao.GenericDao) (finished bool, err *errors.ServiceError)
 
-func (s *sqlGenericService) buildPreload(listCtx *listContext, d *dao.GenericDao) (bool, *errors.ServiceError) {
+func (s *sqlGenericService) buildPreload(listCtx *listContext, d dao.GenericDao) (bool, *errors.ServiceError) {
 	listCtx.set = make(map[string]bool)
 
 	for _, preload := range listCtx.args.Preloads {
@@ -124,26 +122,26 @@ func (s *sqlGenericService) buildPreload(listCtx *listContext, d *dao.GenericDao
 	}
 	// preload each table only once; struct{} doesn't occupy any additional space
 	for _, preload := range listCtx.args.Preloads {
-		(*d).Preload(preload)
+		d.Preload(preload)
 	}
 	return false, nil
 }
 
-func (s *sqlGenericService) buildOrderBy(listCtx *listContext, d *dao.GenericDao) (bool, *errors.ServiceError) {
+func (s *sqlGenericService) buildOrderBy(listCtx *listContext, d dao.GenericDao) (bool, *errors.ServiceError) {
 	if len(listCtx.args.Order) != 0 {
 		cleanedOrderList, serviceErr := db.ArgsToOrder(listCtx.args.Order)
 		if serviceErr != nil {
 			return false, serviceErr
 		}
 		for _, orderArg := range cleanedOrderList {
-			(*d).OrderBy(orderArg)
+			d.OrderBy(orderArg)
 		}
 	}
 	return false, nil
 }
 
 func (s *sqlGenericService) buildSearchValues(
-	listCtx *listContext, d *dao.GenericDao,
+	listCtx *listContext, d dao.GenericDao,
 ) (string, []any, *errors.ServiceError) {
 	if listCtx.args.Search == "" {
 		s.addJoins(listCtx, d)
@@ -225,17 +223,17 @@ func (s *sqlGenericService) buildSearchValues(
 	return sql, values, nil
 }
 
-func (s *sqlGenericService) buildSearch(listCtx *listContext, d *dao.GenericDao) (bool, *errors.ServiceError) {
+func (s *sqlGenericService) buildSearch(listCtx *listContext, d dao.GenericDao) (bool, *errors.ServiceError) {
 	sql, values, err := s.buildSearchValues(listCtx, d)
 	if err != nil {
 		return false, err
 	}
-	(*d).Where(dao.NewWhere(sql, values))
+	d.Where(dao.NewWhere(sql, values))
 	return true, nil
 }
 
 // JOIN the tables that appear in the search string
-func (s *sqlGenericService) addJoins(listCtx *listContext, d *dao.GenericDao) {
+func (s *sqlGenericService) addJoins(listCtx *listContext, d dao.GenericDao) {
 	for _, r := range listCtx.joins {
 		if _, ok := listCtx.set[r.ForeignTableName]; ok {
 			// skip already included preloads
@@ -244,49 +242,37 @@ func (s *sqlGenericService) addJoins(listCtx *listContext, d *dao.GenericDao) {
 		sql := fmt.Sprintf(
 			"LEFT JOIN %s ON %s.%s = %s.%s AND %s.deleted_time IS NULL",
 			r.ForeignTableName, r.ForeignTableName, r.ForeignColumnName, r.TableName, r.ColumnName, r.ForeignTableName)
-		(*d).Joins(sql)
+		d.Joins(sql)
 
 		listCtx.groupBy = append(listCtx.groupBy, r.ForeignTableName+".id")
 		listCtx.set[r.ForeignTableName] = true
 	}
 	if len(listCtx.joins) > 0 {
 		// Add base relation
-		listCtx.groupBy = append(listCtx.groupBy, (*d).GetTableName()+".id")
-		(*d).Group(strings.Join(listCtx.groupBy, ","))
+		listCtx.groupBy = append(listCtx.groupBy, d.GetTableName()+".id")
+		d.Group(strings.Join(listCtx.groupBy, ","))
 	}
 
 	// Reset list of joins and group by's
 	listCtx.joins = map[string]dao.TableRelation{}
 }
 
-func (s *sqlGenericService) loadList(listCtx *listContext, d *dao.GenericDao) *errors.ServiceError {
+func (s *sqlGenericService) loadList(listCtx *listContext, d dao.GenericDao) *errors.ServiceError {
 	args := listCtx.args
 
-	(*d).Count(listCtx.resourceList, &listCtx.pagingMeta.Total)
+	d.Count(listCtx.resourceList, &listCtx.pagingMeta.Total)
 
 	// Set resourceList to be an empty slice with zero capacity. Real space will be allocated by g2.Find()
 	if err := zeroSlice(listCtx.resourceList, 0); err != nil {
 		return err
 	}
 
-	switch {
-	case args.Size > MaxListSize:
-		// Note: Currently unreachable via HTTP requests (capped at MaxPageSize=100),
-		// but kept as defensive check for direct service layer usage.
-		logger.Warn(listCtx.ctx, "A query with a size greater than the maximum was requested.")
-	case args.Size < 0:
-		logger.Warn(listCtx.ctx, "A query with an unbound size was requested.")
-	case args.Size == 0:
-		// This early return is not only performant, but also necessary.
-		// gorm does not support Limit(0) any longer.
-		logger.Info(listCtx.ctx,
-			"A query with 0 size requested, returning early without collecting any resources from database")
+	// gorm does not support Limit(0); also reject negative sizes defensively.
+	if args.Size <= 0 {
 		return nil
 	}
 
-	// NOTE: Limit no longer supports '0' size and will cause issues. There is an early return, do not remove it.
-	//       https://github.com/go-gorm/gorm/blob/master/clause/limit.go#L18-L21
-	if err := (*d).Fetch((args.Page-1)*int(args.Size), int(args.Size), listCtx.resourceList); err != nil {
+	if err := d.Fetch(int((args.Page-1)*args.Size), int(args.Size), listCtx.resourceList); err != nil {
 		switch {
 		case e.Is(err, gorm.ErrRecordNotFound):
 			listCtx.pagingMeta.Size = 0
@@ -320,9 +306,9 @@ func zeroSlice(i interface{}, cap int64) *errors.ServiceError {
 // (1) look up the related table by its 1st part - creator
 // (2) replace it by table name - creator.username -> accounts.username
 func (s *sqlGenericService) treeWalkForRelatedTables(
-	listCtx *listContext, tslTree *tsl.Node, genericDao *dao.GenericDao,
+	listCtx *listContext, tslTree *tsl.Node, genericDao dao.GenericDao,
 ) (*tsl.Node, *errors.ServiceError) {
-	resourceTable := (*genericDao).GetTableName()
+	resourceTable := genericDao.GetTableName()
 	if listCtx.joins == nil {
 		listCtx.joins = map[string]dao.TableRelation{}
 	}
@@ -338,7 +324,7 @@ func (s *sqlGenericService) treeWalkForRelatedTables(
 			fieldName := fieldParts[0]
 			_, exists := listCtx.joins[fieldName]
 			if !exists {
-				if relation, ok := (*genericDao).GetTableRelation(fieldName); ok {
+				if relation, ok := genericDao.GetTableRelation(fieldName); ok {
 					listCtx.joins[fieldName] = relation
 				} else {
 					return field, fmt.Errorf(
@@ -366,9 +352,9 @@ func (s *sqlGenericService) treeWalkForRelatedTables(
 func (s *sqlGenericService) treeWalkForAddingTableName(
 	_ *listContext,
 	tslTree *tsl.Node,
-	dao *dao.GenericDao,
+	d dao.GenericDao,
 ) (*tsl.Node, *errors.ServiceError) {
-	resourceTable := (*dao).GetTableName()
+	resourceTable := d.GetTableName()
 
 	walkFn := func(field string) (string, error) {
 		fieldParts := strings.Split(field, ".")
diff --git a/pkg/services/generic_test.go b/pkg/services/generic_test.go
index 8a6f4548..bfe1e5df 100755
--- a/pkg/services/generic_test.go
+++ b/pkg/services/generic_test.go
@@ -43,7 +43,7 @@ func TestSQLTranslation(t *testing.T) {
 		)
 		Expect(serviceErr).ToNot(HaveOccurred())
 		d := g.GetInstanceDao(context.Background(), model)
-		_, serviceErr = genericService.buildSearch(listCtx, &d)
+		_, serviceErr = genericService.buildSearch(listCtx, d)
 		Expect(serviceErr).To(HaveOccurred())
 		Expect(serviceErr.Type).To(Equal(errors.ErrorTypeBadRequest))
 		Expect(serviceErr.Error()).To(Equal(errorMsg))
@@ -153,9 +153,9 @@ func TestSQLTranslation(t *testing.T) {
 		tslTree, serviceErr = db.FieldNameWalk(tslTree)
 		Expect(serviceErr).ToNot(HaveOccurred())
 		d := g.GetInstanceDao(context.Background(), &api.Resource{})
-		tslTree, serviceErr = genericService.treeWalkForRelatedTables(listCtx, tslTree, &d)
+		tslTree, serviceErr = genericService.treeWalkForRelatedTables(listCtx, tslTree, d)
 		Expect(serviceErr).ToNot(HaveOccurred(), "JSONB field should not be misclassified as related table: %s", search)
-		tslTree, serviceErr = genericService.treeWalkForAddingTableName(listCtx, tslTree, &d)
+		tslTree, serviceErr = genericService.treeWalkForAddingTableName(listCtx, tslTree, d)
 		Expect(serviceErr).ToNot(HaveOccurred())
 		sqlizer, serviceErr := genericService.treeWalkForSqlizer(listCtx, &tsl.TSLNode{Node: tslTree})
 		Expect(serviceErr).ToNot(HaveOccurred())
diff --git a/pkg/services/resource.go b/pkg/services/resource.go
index b4987f30..e0a93ad2 100644
--- a/pkg/services/resource.go
+++ b/pkg/services/resource.go
@@ -17,8 +17,6 @@ import (
 	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/util"
 )
 
-const defaultPageSize = 20
-
 //go:generate go tool -modfile=../../tools/go.mod mockgen -source=resource.go -package=services -destination=resource_mock.go
 
 type ResourceService interface {
@@ -402,7 +400,7 @@ func (s *sqlResourceService) List(
 		return nil, nil, svcErr
 	}
 	if args == nil {
-		args = &ListArguments{Page: 1, Size: defaultPageSize}
+		args = NewListArguments()
 	}
 	scopedArgs := *args
 	scopedArgs.Preloads = append(append([]string(nil), scopedArgs.Preloads...), "Labels", "Conditions", "References")
@@ -433,7 +431,7 @@ func (s *sqlResourceService) ListByOwner(
 		return nil, nil, svcErr
 	}
 	if args == nil {
-		args = &ListArguments{Page: 1, Size: defaultPageSize}
+		args = NewListArguments()
 	}
 	scopedArgs := *args
 	scopedArgs.Preloads = append(append([]string(nil), scopedArgs.Preloads...), "Labels", "Conditions", "References")
@@ -473,7 +471,7 @@ func (s *sqlResourceService) ListAll(
 	ctx context.Context, args *ListArguments,
 ) (api.ResourceList, *api.PagingMeta, *errors.ServiceError) {
 	if args == nil {
-		args = &ListArguments{Page: 1, Size: defaultPageSize}
+		args = NewListArguments()
 	}
 	scopedArgs := *args
 	scopedArgs.Preloads = append(append([]string(nil), scopedArgs.Preloads...), "Labels", "Conditions", "References")
diff --git a/pkg/services/types.go b/pkg/services/types.go
old mode 100755
new mode 100644
index 2591f703..baf6c7e0
--- a/pkg/services/types.go
+++ b/pkg/services/types.go
@@ -1,13 +1,5 @@
 package services
 
-import (
-	"net/url"
-	"strconv"
-	"strings"
-
-	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/errors"
-)
-
 // ListArguments are arguments relevant for listing objects.
 // This struct is common to all service List funcs in this package
 type ListArguments struct {
@@ -18,131 +10,12 @@ type ListArguments struct {
 	Order       []string
 	Fields      []string
 	Size        int64
-	Page        int
-}
-
-// MaxListSize defines the PostgreSQL WHERE IN clause parameter limit (~65500).
-// Note: This is currently unreachable via HTTP requests since MaxPageSize caps at 100,
-// but is kept as a defensive check for direct service layer usage and to document the
-// technical database constraint.
-const MaxListSize = 65500
-
-// MaxPageSize is the maximum allowed page size for pagination via HTTP requests.
-// Set to 100 to prevent excessive resource usage and ensure reasonable response times.
-const MaxPageSize = 100
-
-// ParseFieldsParameter extracts and parses the ?fields query parameter.
-// Returns a slice of field names with "id" always included when valid fields are provided.
-// Returns nil if no valid fields are specified (empty or whitespace-only parameter).
-func ParseFieldsParameter(params url.Values) []string {
-	if v := strings.TrimSpace(params.Get("fields")); v != "" {
-		fields := strings.Split(v, ",")
-		result := make([]string, 0, len(fields)+1)
-		idPresent := false
-		for _, field := range fields {
-			trimmed := strings.TrimSpace(field)
-			if trimmed == "" {
-				continue
-			}
-			if trimmed == "id" {
-				idPresent = true
-			}
-			result = append(result, trimmed)
-		}
-		// If no valid fields were provided (e.g., "fields=" or "fields=   "), return nil
-		if len(result) == 0 {
-			return nil
-		}
-		// Always include id field when user provided valid fields
-		if !idPresent {
-			result = append(result, "id")
-		}
-		return result
-	}
-	return nil
+	Page        int64
 }
 
-// NewListArguments Create ListArguments from url query parameters with sane defaults
-// Returns an error if page or size parameters are invalid (negative, non-numeric, or out of range)
-func NewListArguments(params url.Values) (*ListArguments, *errors.ServiceError) {
-	listArgs := &ListArguments{
-		Page:   1,
-		Size:   20,
-		Search: "",
-	}
-
-	// Validate page parameter
-	if v := strings.Trim(params.Get("page"), " "); v != "" {
-		page, err := strconv.Atoi(v)
-		if err != nil {
-			return nil, errors.New(
-				errors.CodeValidationFormat,
-				"Invalid page parameter: must be a positive integer",
-			)
-		}
-		if page < 1 {
-			return nil, errors.New(
-				errors.CodeValidationRange,
-				"Invalid page parameter: %d is less than 1",
-				page,
-			)
-		}
-		listArgs.Page = page
-	}
-
-	// Validate size parameter
-	if v := strings.Trim(params.Get("size"), " "); v != "" {
-		size, err := strconv.ParseInt(v, 10, 64)
-		if err != nil {
-			return nil, errors.New(
-				errors.CodeValidationFormat,
-				"Invalid size parameter: must be a positive integer",
-			)
-		}
-		if size < 1 {
-			return nil, errors.New(
-				errors.CodeValidationRange,
-				"Invalid size parameter: %d is less than 1",
-				size,
-			)
-		}
-		if size > MaxPageSize {
-			return nil, errors.New(
-				errors.CodeValidationRange,
-				"Invalid size parameter: %d exceeds maximum allowed value of %d",
-				size, MaxPageSize,
-			)
-		}
-		listArgs.Size = size
-	}
-
-	if v := strings.Trim(params.Get("search"), " "); v != "" {
-		listArgs.Search = v
-	}
-	if v := strings.Trim(params.Get("order"), " "); v != "" {
-		rawFields := strings.Split(v, ",")
-		for _, field := range rawFields {
-			if trimmed := strings.TrimSpace(field); trimmed != "" {
-				listArgs.Order = append(listArgs.Order, strings.Join(strings.Fields(trimmed), " "))
-			}
-		}
-	}
-
-	if len(listArgs.Order) == 0 {
-		listArgs.Order = []string{"created_time desc"}
+func NewListArguments() *ListArguments {
+	return &ListArguments{
+		Page: 1,
+		Size: 20,
 	}
-
-	// Parse fields parameter using shared logic
-	listArgs.Fields = ParseFieldsParameter(params)
-
-	listArgs.RefType = strings.TrimSpace(params.Get("ref_type"))
-	listArgs.RefTargetID = strings.TrimSpace(params.Get("ref_target_id"))
-	if (listArgs.RefType == "") != (listArgs.RefTargetID == "") {
-		return nil, errors.New(
-			errors.CodeValidationFormat,
-			"ref_type and ref_target_id must be provided together",
-		)
-	}
-
-	return listArgs, nil
 }
diff --git a/pkg/services/types_test.go b/pkg/services/types_test.go
deleted file mode 100644
index db20150a..00000000
--- a/pkg/services/types_test.go
+++ /dev/null
@@ -1,369 +0,0 @@
-package services
-
-import (
-	"net/url"
-	"reflect"
-	"testing"
-
-	. "github.com/onsi/gomega"
-)
-
-func TestNewListArguments_Order(t *testing.T) {
-	RegisterTestingT(t)
-
-	tests := []struct {
-		name          string
-		queryParams   url.Values
-		expectedOrder []string
-	}{
-		{
-			name:          "no order - should use default created_time desc",
-			queryParams:   url.Values{},
-			expectedOrder: []string{"created_time desc"},
-		},
-		{
-			name:          "order with asc direction",
-			queryParams:   url.Values{"order": []string{"name asc"}},
-			expectedOrder: []string{"name asc"},
-		},
-		{
-			name:          "order with desc direction",
-			queryParams:   url.Values{"order": []string{"name desc"}},
-			expectedOrder: []string{"name desc"},
-		},
-		{
-			name:          "order without direction",
-			queryParams:   url.Values{"order": []string{"name"}},
-			expectedOrder: []string{"name"},
-		},
-		{
-			name:          "multiple order fields",
-			queryParams:   url.Values{"order": []string{"name asc,created_time desc"}},
-			expectedOrder: []string{"name asc", "created_time desc"},
-		},
-		{
-			name:          "order with spaces should be trimmed",
-			queryParams:   url.Values{"order": []string{" name asc "}},
-			expectedOrder: []string{"name asc"},
-		},
-		{
-			name:          "empty order string - should use default",
-			queryParams:   url.Values{"order": []string{""}},
-			expectedOrder: []string{"created_time desc"},
-		},
-		{
-			name:          "order with whitespace only - should use default",
-			queryParams:   url.Values{"order": []string{"   "}},
-			expectedOrder: []string{"created_time desc"},
-		},
-		{
-			name:          "order with empty tokens - should filter out",
-			queryParams:   url.Values{"order": []string{"name,,created_time"}},
-			expectedOrder: []string{"name", "created_time"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			RegisterTestingT(t)
-			listArgs, err := NewListArguments(tt.queryParams)
-			Expect(err).To(BeNil(), "Should not return error for valid order parameters")
-			Expect(listArgs.Order).To(Equal(tt.expectedOrder),
-				"Order mismatch for test case: %s", tt.name)
-		})
-	}
-}
-
-func TestNewListArguments_DefaultValues(t *testing.T) {
-	RegisterTestingT(t)
-
-	listArgs, err := NewListArguments(url.Values{})
-
-	Expect(err).To(BeNil(), "Should not return error for default values")
-	Expect(listArgs.Page).To(Equal(1), "Default page should be 1")
-	Expect(listArgs.Size).To(Equal(int64(20)), "Default size should be 20")
-	Expect(listArgs.Search).To(Equal(""), "Default search should be empty")
-	Expect(listArgs.Order).To(Equal([]string{"created_time desc"}), "Default order should be created_time desc")
-}
-
-func TestNewListArguments_Size(t *testing.T) {
-	RegisterTestingT(t)
-
-	tests := []struct {
-		queryParams  url.Values
-		name         string
-		expectedPage int
-		expectedSize int64
-	}{
-		{
-			name:         "custom page and size",
-			queryParams:  url.Values{"page": []string{"2"}, "size": []string{"50"}},
-			expectedPage: 2,
-			expectedSize: 50,
-		},
-		{
-			name:         "custom page and size (different values)",
-			queryParams:  url.Values{"page": []string{"3"}, "size": []string{"25"}},
-			expectedPage: 3,
-			expectedSize: 25,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			RegisterTestingT(t)
-			listArgs, err := NewListArguments(tt.queryParams)
-			Expect(err).To(BeNil(), "Should not return error for valid parameters")
-			Expect(listArgs.Page).To(Equal(tt.expectedPage), "Page mismatch")
-			Expect(listArgs.Size).To(Equal(tt.expectedSize), "Size mismatch")
-		})
-	}
-}
-
-func TestNewListArguments_Search(t *testing.T) {
-	RegisterTestingT(t)
-
-	tests := []struct {
-		name           string
-		queryParams    url.Values
-		expectedSearch string
-	}{
-		{
-			name:           "no search parameter",
-			queryParams:    url.Values{},
-			expectedSearch: "",
-		},
-		{
-			name:           "search with value",
-			queryParams:    url.Values{"search": []string{"name='test'"}},
-			expectedSearch: "name='test'",
-		},
-		{
-			name:           "search with spaces should be trimmed",
-			queryParams:    url.Values{"search": []string{"  name='test'  "}},
-			expectedSearch: "name='test'",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			RegisterTestingT(t)
-			listArgs, err := NewListArguments(tt.queryParams)
-			Expect(err).To(BeNil(), "Should not return error for valid search parameters")
-			Expect(listArgs.Search).To(Equal(tt.expectedSearch), "Search mismatch")
-		})
-	}
-}
-
-func TestNewListArguments_Fields(t *testing.T) {
-	RegisterTestingT(t)
-
-	tests := []struct {
-		name           string
-		queryParams    url.Values
-		expectedFields []string
-	}{
-		{
-			name:           "no fields parameter",
-			queryParams:    url.Values{},
-			expectedFields: nil,
-		},
-		{
-			name:           "fields without id - should add id automatically",
-			queryParams:    url.Values{"fields": []string{"name,status"}},
-			expectedFields: []string{"name", "status", "id"},
-		},
-		{
-			name:           "fields with id - should not duplicate",
-			queryParams:    url.Values{"fields": []string{"id,name,status"}},
-			expectedFields: []string{"id", "name", "status"},
-		},
-		{
-			name:           "fields with spaces and commas",
-			queryParams:    url.Values{"fields": []string{" name , status , id "}},
-			expectedFields: []string{"name", "status", "id"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			RegisterTestingT(t)
-			listArgs, err := NewListArguments(tt.queryParams)
-			Expect(err).To(BeNil(), "Should not return error for valid fields parameters")
-			if !reflect.DeepEqual(listArgs.Fields, tt.expectedFields) {
-				t.Errorf("Fields = %v, want %v", listArgs.Fields, tt.expectedFields)
-			}
-		})
-	}
-}
-
-func TestNewListArguments_RefTypeWithoutTargetID_Returns400(t *testing.T) {
-	RegisterTestingT(t)
-
-	params := url.Values{"ref_type": []string{"dep"}}
-	listArgs, err := NewListArguments(params)
-	Expect(listArgs).To(BeNil())
-	Expect(err).ToNot(BeNil())
-	Expect(err.HTTPCode).To(Equal(400))
-	Expect(err.Reason).To(ContainSubstring("ref_type and ref_target_id must be provided together"))
-}
-
-func TestNewListArguments_RefTargetIDWithoutRefType_Returns400(t *testing.T) {
-	RegisterTestingT(t)
-
-	params := url.Values{"ref_target_id": []string{"some-id"}}
-	listArgs, err := NewListArguments(params)
-	Expect(listArgs).To(BeNil())
-	Expect(err).ToNot(BeNil())
-	Expect(err.HTTPCode).To(Equal(400))
-	Expect(err.Reason).To(ContainSubstring("ref_type and ref_target_id must be provided together"))
-}
-
-func TestNewListArguments_RefTypePairValid(t *testing.T) {
-	RegisterTestingT(t)
-
-	params := url.Values{
-		"ref_type":      []string{"dep"},
-		"ref_target_id": []string{"target-1"},
-	}
-	listArgs, err := NewListArguments(params)
-	Expect(err).To(BeNil())
-	Expect(listArgs.RefType).To(Equal("dep"))
-	Expect(listArgs.RefTargetID).To(Equal("target-1"))
-}
-
-// TestNewListArguments_Validation tests pagination parameter validation (HYPERFLEET-1241)
-func TestNewListArguments_Validation(t *testing.T) {
-	RegisterTestingT(t)
-
-	tests := []struct {
-		name          string
-		queryParams   url.Values
-		errorContains string
-		errorCode     string
-		expectError   bool
-	}{
-		// Page validation tests
-		// Page boundary checks — VAL-004 (CodeValidationRange) for values outside valid range
-		{
-			name:          "negative page returns error",
-			queryParams:   url.Values{"page": []string{"-1"}},
-			expectError:   true,
-			errorContains: "Invalid page parameter",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		{
-			name:          "zero page returns error",
-			queryParams:   url.Values{"page": []string{"0"}},
-			expectError:   true,
-			errorContains: "Invalid page parameter",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		// Page parse errors — VAL-003 (CodeValidationFormat) for non-numeric input
-		{
-			name:          "non-numeric page returns error",
-			queryParams:   url.Values{"page": []string{"abc"}},
-			expectError:   true,
-			errorContains: "Invalid page parameter",
-			errorCode:     "HYPERFLEET-VAL-003",
-		},
-		{
-			name:          "page with special characters returns error",
-			queryParams:   url.Values{"page": []string{"<script>"}},
-			expectError:   true,
-			errorContains: "Invalid page parameter",
-			errorCode:     "HYPERFLEET-VAL-003",
-		},
-
-		// Size validation tests
-		// Size boundary checks — VAL-004 (CodeValidationRange) for values outside valid range (1-100)
-		{
-			name:          "negative size returns error",
-			queryParams:   url.Values{"size": []string{"-1"}},
-			expectError:   true,
-			errorContains: "Invalid size parameter",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		{
-			name:          "zero size returns error",
-			queryParams:   url.Values{"size": []string{"0"}},
-			expectError:   true,
-			errorContains: "Invalid size parameter",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		{
-			name:          "size exceeding MaxPageSize returns error",
-			queryParams:   url.Values{"size": []string{"101"}},
-			expectError:   true,
-			errorContains: "exceeds maximum allowed value",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		// Size parse errors — VAL-003 (CodeValidationFormat) for non-numeric input
-		{
-			name:          "non-numeric size returns error",
-			queryParams:   url.Values{"size": []string{"xyz"}},
-			expectError:   true,
-			errorContains: "Invalid size parameter",
-			errorCode:     "HYPERFLEET-VAL-003",
-		},
-
-		// Additional size edge cases
-		{
-			name:          "size with special characters returns error",
-			queryParams:   url.Values{"size": []string{"<script>"}},
-			expectError:   true,
-			errorContains: "Invalid size parameter",
-			errorCode:     "HYPERFLEET-VAL-003",
-		},
-		{
-			name:          "very large size returns error",
-			queryParams:   url.Values{"size": []string{"999999"}},
-			expectError:   true,
-			errorContains: "exceeds maximum allowed value",
-			errorCode:     "HYPERFLEET-VAL-004",
-		},
-		{
-			name:        "pageSize is ignored (no longer a valid parameter)",
-			queryParams: url.Values{"pageSize": []string{"50"}},
-			expectError: false,
-		},
-
-		// Valid cases
-		{
-			name:        "valid page=1 size=1",
-			queryParams: url.Values{"page": []string{"1"}, "size": []string{"1"}},
-			expectError: false,
-		},
-		{
-			name:        "valid page=1 size=100 (max)",
-			queryParams: url.Values{"page": []string{"1"}, "size": []string{"100"}},
-			expectError: false,
-		},
-		{
-			name:        "valid page=999 size=50",
-			queryParams: url.Values{"page": []string{"999"}, "size": []string{"50"}},
-			expectError: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			RegisterTestingT(t)
-			listArgs, err := NewListArguments(tt.queryParams)
-
-			if tt.expectError {
-				Expect(err).ToNot(BeNil(), "Expected error but got nil")
-				Expect(err.Reason).To(ContainSubstring(tt.errorContains),
-					"Error message should contain expected text")
-				Expect(err.RFC9457Code).To(Equal(tt.errorCode),
-					"Error code should match expected value")
-				Expect(err.HTTPCode).To(Equal(400),
-					"HTTP code should be 400 for validation errors")
-				Expect(listArgs).To(BeNil(), "ListArgs should be nil on error")
-			} else {
-				Expect(err).To(BeNil(), "Should not return error for valid parameters")
-				Expect(listArgs).ToNot(BeNil(), "ListArgs should not be nil")
-			}
-		})
-	}
-}
