diff --git a/.github/workflows/ci-go.yml b/.github/workflows/ci-go.yml
index e5c504c6e6..b8042ee82b 100644
--- a/.github/workflows/ci-go.yml
+++ b/.github/workflows/ci-go.yml
@@ -57,7 +57,7 @@ jobs:
       - run: go mod download
       - run: go test -coverprofile=coverage.out ./...
       - run: go tool cover -html=coverage.out -o coverage.html
-      - uses: actions/upload-artifact@89ef406dd8d7e03cfd12d9e0a4a378f454709029 # v4.3.5
+      - uses: actions/upload-artifact@834a144ee995460fba8ed112a2fc961b36a5ec5a # v4.3.6
         with:
           name: go-${{ matrix.go-version }}-coverage
           path: coverage.html
diff --git a/.golangci.yml b/.golangci.yml
index 4b020fab98..c9a4ab3b83 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -24,7 +24,7 @@ linters:
     - unconvert
     - unparam
     - unused
-    - vet
+    - govet
 
 run:
   # Prevent false positive timeouts in CI
diff --git a/helper/acctest/random.go b/helper/acctest/random.go
index c26303eb60..382163cbc2 100644
--- a/helper/acctest/random.go
+++ b/helper/acctest/random.go
@@ -34,9 +34,9 @@ func RandomWithPrefix(name string) string {
 	return fmt.Sprintf("%s-%d", name, RandInt())
 }
 
-// RandIntRange returns a random integer between min (inclusive) and max (exclusive)
-func RandIntRange(min int, max int) int {
-	return rand.Intn(max-min) + min
+// RandIntRange returns a random integer between minVal (inclusive) and maxVal (exclusive)
+func RandIntRange(minVal int, maxVal int) int {
+	return rand.Intn(maxVal-minVal) + minVal
 }
 
 // RandString generates a random alphanumeric string of the length specified
diff --git a/helper/schema/shims_test.go b/helper/schema/shims_test.go
index a8a2a56743..441ba9ec07 100644
--- a/helper/schema/shims_test.go
+++ b/helper/schema/shims_test.go
@@ -81,7 +81,7 @@ func testApplyDiff(t *testing.T,
 	}
 
 	if !cmp.Equal(expectedState, newState, equateEmpty, typeComparer, valueComparer) {
-		t.Fatalf(cmp.Diff(expectedState, newState, equateEmpty, typeComparer, valueComparer))
+		t.Fatal(cmp.Diff(expectedState, newState, equateEmpty, typeComparer, valueComparer))
 	}
 }
 
diff --git a/helper/validation/float.go b/helper/validation/float.go
index dfc261842d..2573c33786 100644
--- a/helper/validation/float.go
+++ b/helper/validation/float.go
@@ -10,8 +10,8 @@ import (
 )
 
 // FloatBetween returns a SchemaValidateFunc which tests if the provided value
-// is of type float64 and is between min and max (inclusive).
-func FloatBetween(min, max float64) schema.SchemaValidateFunc {
+// is of type float64 and is between minVal and maxVal (inclusive).
+func FloatBetween(minVal, maxVal float64) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (s []string, es []error) {
 		v, ok := i.(float64)
 		if !ok {
@@ -19,8 +19,8 @@ func FloatBetween(min, max float64) schema.SchemaValidateFunc {
 			return
 		}
 
-		if v < min || v > max {
-			es = append(es, fmt.Errorf("expected %s to be in the range (%f - %f), got %f", k, min, max, v))
+		if v < minVal || v > maxVal {
+			es = append(es, fmt.Errorf("expected %s to be in the range (%f - %f), got %f", k, minVal, maxVal, v))
 			return
 		}
 
@@ -29,8 +29,8 @@ func FloatBetween(min, max float64) schema.SchemaValidateFunc {
 }
 
 // FloatAtLeast returns a SchemaValidateFunc which tests if the provided value
-// is of type float and is at least min (inclusive)
-func FloatAtLeast(min float64) schema.SchemaValidateFunc {
+// is of type float and is at least minVal (inclusive)
+func FloatAtLeast(minVal float64) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (s []string, es []error) {
 		v, ok := i.(float64)
 		if !ok {
@@ -38,8 +38,8 @@ func FloatAtLeast(min float64) schema.SchemaValidateFunc {
 			return
 		}
 
-		if v < min {
-			es = append(es, fmt.Errorf("expected %s to be at least (%f), got %f", k, min, v))
+		if v < minVal {
+			es = append(es, fmt.Errorf("expected %s to be at least (%f), got %f", k, minVal, v))
 			return
 		}
 
@@ -48,8 +48,8 @@ func FloatAtLeast(min float64) schema.SchemaValidateFunc {
 }
 
 // FloatAtMost returns a SchemaValidateFunc which tests if the provided value
-// is of type float and is at most max (inclusive)
-func FloatAtMost(max float64) schema.SchemaValidateFunc {
+// is of type float and is at most maxVal (inclusive)
+func FloatAtMost(maxVal float64) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (s []string, es []error) {
 		v, ok := i.(float64)
 		if !ok {
@@ -57,8 +57,8 @@ func FloatAtMost(max float64) schema.SchemaValidateFunc {
 			return
 		}
 
-		if v > max {
-			es = append(es, fmt.Errorf("expected %s to be at most (%f), got %f", k, max, v))
+		if v > maxVal {
+			es = append(es, fmt.Errorf("expected %s to be at most (%f), got %f", k, maxVal, v))
 			return
 		}
 
diff --git a/helper/validation/int.go b/helper/validation/int.go
index 2873897f27..a240e447a9 100644
--- a/helper/validation/int.go
+++ b/helper/validation/int.go
@@ -11,8 +11,8 @@ import (
 )
 
 // IntBetween returns a SchemaValidateFunc which tests if the provided value
-// is of type int and is between min and max (inclusive)
-func IntBetween(min, max int) schema.SchemaValidateFunc {
+// is of type int and is between minVal and maxVal (inclusive)
+func IntBetween(minVal, maxVal int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
@@ -20,8 +20,8 @@ func IntBetween(min, max int) schema.SchemaValidateFunc {
 			return warnings, errors
 		}
 
-		if v < min || v > max {
-			errors = append(errors, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, min, max, v))
+		if v < minVal || v > maxVal {
+			errors = append(errors, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, minVal, maxVal, v))
 			return warnings, errors
 		}
 
@@ -30,8 +30,8 @@ func IntBetween(min, max int) schema.SchemaValidateFunc {
 }
 
 // IntAtLeast returns a SchemaValidateFunc which tests if the provided value
-// is of type int and is at least min (inclusive)
-func IntAtLeast(min int) schema.SchemaValidateFunc {
+// is of type int and is at least minVal (inclusive)
+func IntAtLeast(minVal int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
@@ -39,8 +39,8 @@ func IntAtLeast(min int) schema.SchemaValidateFunc {
 			return warnings, errors
 		}
 
-		if v < min {
-			errors = append(errors, fmt.Errorf("expected %s to be at least (%d), got %d", k, min, v))
+		if v < minVal {
+			errors = append(errors, fmt.Errorf("expected %s to be at least (%d), got %d", k, minVal, v))
 			return warnings, errors
 		}
 
@@ -49,8 +49,8 @@ func IntAtLeast(min int) schema.SchemaValidateFunc {
 }
 
 // IntAtMost returns a SchemaValidateFunc which tests if the provided value
-// is of type int and is at most max (inclusive)
-func IntAtMost(max int) schema.SchemaValidateFunc {
+// is of type int and is at most maxVal (inclusive)
+func IntAtMost(maxVal int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
@@ -58,8 +58,8 @@ func IntAtMost(max int) schema.SchemaValidateFunc {
 			return warnings, errors
 		}
 
-		if v > max {
-			errors = append(errors, fmt.Errorf("expected %s to be at most (%d), got %d", k, max, v))
+		if v > maxVal {
+			errors = append(errors, fmt.Errorf("expected %s to be at most (%d), got %d", k, maxVal, v))
 			return warnings, errors
 		}
 
diff --git a/helper/validation/map.go b/helper/validation/map.go
index 7c92509054..1465859870 100644
--- a/helper/validation/map.go
+++ b/helper/validation/map.go
@@ -9,23 +9,24 @@ import (
 	"sort"
 
 	"github.com/hashicorp/go-cty/cty"
+
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 // MapKeyLenBetween returns a SchemaValidateDiagFunc which tests if the provided value
-// is of type map and the length of all keys are between min and max (inclusive)
-func MapKeyLenBetween(min, max int) schema.SchemaValidateDiagFunc {
+// is of type map and the length of all keys are between minVal and maxVal (inclusive)
+func MapKeyLenBetween(minVal, maxVal int) schema.SchemaValidateDiagFunc {
 	return func(v interface{}, path cty.Path) diag.Diagnostics {
 		var diags diag.Diagnostics
 
 		for _, key := range sortedKeys(v.(map[string]interface{})) {
 			keyLen := len(key)
-			if keyLen < min || keyLen > max {
+			if keyLen < minVal || keyLen > maxVal {
 				diags = append(diags, diag.Diagnostic{
 					Severity:      diag.Error,
 					Summary:       "Bad map key length",
-					Detail:        fmt.Sprintf("Map key lengths should be in the range (%d - %d): %s (length = %d)", min, max, key, keyLen),
+					Detail:        fmt.Sprintf("Map key lengths should be in the range (%d - %d): %s (length = %d)", minVal, maxVal, key, keyLen),
 					AttributePath: append(path, cty.IndexStep{Key: cty.StringVal(key)}),
 				})
 			}
@@ -36,8 +37,8 @@ func MapKeyLenBetween(min, max int) schema.SchemaValidateDiagFunc {
 }
 
 // MapValueLenBetween returns a SchemaValidateDiagFunc which tests if the provided value
-// is of type map and the length of all values are between min and max (inclusive)
-func MapValueLenBetween(min, max int) schema.SchemaValidateDiagFunc {
+// is of type map and the length of all values are between minVal and maxVal (inclusive)
+func MapValueLenBetween(minVal, maxVal int) schema.SchemaValidateDiagFunc {
 	return func(v interface{}, path cty.Path) diag.Diagnostics {
 		var diags diag.Diagnostics
 
@@ -57,11 +58,11 @@ func MapValueLenBetween(min, max int) schema.SchemaValidateDiagFunc {
 			}
 
 			valLen := len(val.(string))
-			if valLen < min || valLen > max {
+			if valLen < minVal || valLen > maxVal {
 				diags = append(diags, diag.Diagnostic{
 					Severity:      diag.Error,
 					Summary:       "Bad map value length",
-					Detail:        fmt.Sprintf("Map value lengths should be in the range (%d - %d): %s => %v (length = %d)", min, max, key, val, valLen),
+					Detail:        fmt.Sprintf("Map value lengths should be in the range (%d - %d): %s => %v (length = %d)", minVal, maxVal, key, val, valLen),
 					AttributePath: append(path, cty.IndexStep{Key: cty.StringVal(key)}),
 				})
 			}
diff --git a/helper/validation/network.go b/helper/validation/network.go
index 9bc6da2b8e..1aadcdb981 100644
--- a/helper/validation/network.go
+++ b/helper/validation/network.go
@@ -99,8 +99,8 @@ func IsCIDR(i interface{}, k string) (warnings []string, errors []error) {
 }
 
 // IsCIDRNetwork returns a SchemaValidateFunc which tests if the provided value
-// is of type string, is in valid Value network notation, and has significant bits between min and max (inclusive)
-func IsCIDRNetwork(min, max int) schema.SchemaValidateFunc {
+// is of type string, is in valid Value network notation, and has significant bits between minVal and maxVal (inclusive)
+func IsCIDRNetwork(minVal, maxVal int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(string)
 		if !ok {
@@ -120,8 +120,8 @@ func IsCIDRNetwork(min, max int) schema.SchemaValidateFunc {
 		}
 
 		sigbits, _ := ipnet.Mask.Size()
-		if sigbits < min || sigbits > max {
-			errors = append(errors, fmt.Errorf("expected %q to contain a network Value with between %d and %d significant bits, got: %d", k, min, max, sigbits))
+		if sigbits < minVal || sigbits > maxVal {
+			errors = append(errors, fmt.Errorf("expected %q to contain a network Value with between %d and %d significant bits, got: %d", k, minVal, maxVal, sigbits))
 		}
 
 		return warnings, errors
diff --git a/helper/validation/strings.go b/helper/validation/strings.go
index 375a698f2c..d8c2243937 100644
--- a/helper/validation/strings.go
+++ b/helper/validation/strings.go
@@ -70,8 +70,8 @@ func StringIsWhiteSpace(i interface{}, k string) ([]string, []error) {
 }
 
 // StringLenBetween returns a SchemaValidateFunc which tests if the provided value
-// is of type string and has length between min and max (inclusive)
-func StringLenBetween(min, max int) schema.SchemaValidateFunc {
+// is of type string and has length between minVal and maxVal (inclusive)
+func StringLenBetween(minVal, maxVal int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(string)
 		if !ok {
@@ -79,8 +79,8 @@ func StringLenBetween(min, max int) schema.SchemaValidateFunc {
 			return warnings, errors
 		}
 
-		if len(v) < min || len(v) > max {
-			errors = append(errors, fmt.Errorf("expected length of %s to be in the range (%d - %d), got %s", k, min, max, v))
+		if len(v) < minVal || len(v) > maxVal {
+			errors = append(errors, fmt.Errorf("expected length of %s to be in the range (%d - %d), got %s", k, minVal, maxVal, v))
 		}
 
 		return warnings, errors