rebase: bump the github-dependencies group in /e2e with 2 updates

Bumps the github-dependencies group in /e2e with 2 updates: [github.com/onsi/ginkgo/v2](https://github.com/onsi/ginkgo) and [github.com/onsi/gomega](https://github.com/onsi/gomega).


Updates `github.com/onsi/ginkgo/v2` from 2.23.0 to 2.23.3
- [Release notes](https://github.com/onsi/ginkgo/releases)
- [Changelog](https://github.com/onsi/ginkgo/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/ginkgo/compare/v2.23.0...v2.23.3)

Updates `github.com/onsi/gomega` from 1.36.2 to 1.36.3
- [Release notes](https://github.com/onsi/gomega/releases)
- [Changelog](https://github.com/onsi/gomega/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/gomega/compare/v1.36.2...v1.36.3)

---
updated-dependencies:
- dependency-name: github.com/onsi/ginkgo/v2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-dependencies
- dependency-name: github.com/onsi/gomega
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-dependencies
...

Signed-off-by: dependabot[bot] <support@github.com>

e2e/go.mod

@@ -14,8 +14,8 @@ require (
 	github.com/ceph/ceph-csi v2.0.1+incompatible
 	github.com/ceph/ceph-csi/api v0.0.0-00010101000000-000000000000
 	github.com/kubernetes-csi/external-snapshotter/client/v8 v8.2.0
-	github.com/onsi/ginkgo/v2 v2.23.0
+	github.com/onsi/ginkgo/v2 v2.23.3
-	github.com/onsi/gomega v1.36.2
+	github.com/onsi/gomega v1.36.3
 	// when updating k8s.io modules, update the 'replace' section below too
 	k8s.io/api v0.32.3
 	k8s.io/apimachinery v0.32.3
@@ -76,7 +76,7 @@ require (
 	github.com/google/cadvisor v0.51.0 // indirect
 	github.com/google/cel-go v0.22.0 // indirect
 	github.com/google/gnostic-models v0.6.9 // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/pprof v0.0.0-20241210010833-40e02aabc2ad // indirect
 	github.com/google/uuid v1.6.0 // indirect

e2e/go.sum

@@ -94,8 +94,8 @@ github.com/google/cel-go v0.22.0/go.mod h1:BuznPXXfQDpXKWQ9sPW3TzlAJN5zzFe+i9tIs
 github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw=
 github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
 github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -156,10 +156,10 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
-github.com/onsi/ginkgo/v2 v2.23.0 h1:FA1xjp8ieYDzlgS5ABTpdUDB7wtngggONc8a7ku2NqQ=
+github.com/onsi/ginkgo/v2 v2.23.3 h1:edHxnszytJ4lD9D5Jjc4tiDkPBZ3siDeJJkUZJJVkp0=
-github.com/onsi/ginkgo/v2 v2.23.0/go.mod h1:zXTP6xIp3U8aVuXN8ENK9IXRaTjFnpVB9mGmaSRvxnM=
+github.com/onsi/ginkgo/v2 v2.23.3/go.mod h1:zXTP6xIp3U8aVuXN8ENK9IXRaTjFnpVB9mGmaSRvxnM=
-github.com/onsi/gomega v1.36.2 h1:koNYke6TVk6ZmnyHrCXba/T/MoLBXFjeC1PtvYgw0A8=
+github.com/onsi/gomega v1.36.3 h1:hID7cr8t3Wp26+cYnfcjR6HpJ00fdogN6dqZ1t6IylU=
-github.com/onsi/gomega v1.36.2/go.mod h1:DdwyADRjrc825LhMEkD76cHR5+pUnjhUN8GlHlRPHzY=
+github.com/onsi/gomega v1.36.3/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=

e2e/vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go

@@ -14,22 +14,29 @@ import (
 )
 
 // SortSlices returns a [cmp.Transformer] option that sorts all []V.
-// The less function must be of the form "func(T, T) bool" which is used to
+// The lessOrCompareFunc function must be either
-// sort any slice with element type V that is assignable to T.
+// a less function of the form "func(T, T) bool" or
+// a compare function of the format "func(T, T) int"
+// which is used to sort any slice with element type V that is assignable to T.
 //
-// The less function must be:
+// A less function must be:
 //   - Deterministic: less(x, y) == less(x, y)
 //   - Irreflexive: !less(x, x)
 //   - Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
 //
-// The less function does not have to be "total". That is, if !less(x, y) and
+// A compare function must be:
-// !less(y, x) for two elements x and y, their relative order is maintained.
+//   - Deterministic: compare(x, y) == compare(x, y)
+//   - Irreflexive: compare(x, x) == 0
+//   - Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
+//
+// The function does not have to be "total". That is, if x != y, but
+// less or compare report inequality, their relative order is maintained.
 //
 // SortSlices can be used in conjunction with [EquateEmpty].
-func SortSlices(lessFunc interface{}) cmp.Option {
+func SortSlices(lessOrCompareFunc interface{}) cmp.Option {
-	vf := reflect.ValueOf(lessFunc)
+	vf := reflect.ValueOf(lessOrCompareFunc)
-	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+	if (!function.IsType(vf.Type(), function.Less) && !function.IsType(vf.Type(), function.Compare)) || vf.IsNil() {
-		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+		panic(fmt.Sprintf("invalid less or compare function: %T", lessOrCompareFunc))
 	}
 	ss := sliceSorter{vf.Type().In(0), vf}
 	return cmp.FilterValues(ss.filter, cmp.Transformer("cmpopts.SortSlices", ss.sort))
@@ -79,28 +86,40 @@ func (ss sliceSorter) checkSort(v reflect.Value) {
 }
 func (ss sliceSorter) less(v reflect.Value, i, j int) bool {
 	vx, vy := v.Index(i), v.Index(j)
-	return ss.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+	vo := ss.fnc.Call([]reflect.Value{vx, vy})[0]
+	if vo.Kind() == reflect.Bool {
+		return vo.Bool()
+	} else {
+		return vo.Int() < 0
+	}
 }
 
-// SortMaps returns a [cmp.Transformer] option that flattens map[K]V types to be a
+// SortMaps returns a [cmp.Transformer] option that flattens map[K]V types to be
-// sorted []struct{K, V}. The less function must be of the form
+// a sorted []struct{K, V}. The lessOrCompareFunc function must be either
-// "func(T, T) bool" which is used to sort any map with key K that is
+// a less function of the form "func(T, T) bool" or
-// assignable to T.
+// a compare function of the format "func(T, T) int"
+// which is used to sort any map with key K that is assignable to T.
 //
 // Flattening the map into a slice has the property that [cmp.Equal] is able to
 // use [cmp.Comparer] options on K or the K.Equal method if it exists.
 //
-// The less function must be:
+// A less function must be:
 //   - Deterministic: less(x, y) == less(x, y)
 //   - Irreflexive: !less(x, x)
 //   - Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
 //   - Total: if x != y, then either less(x, y) or less(y, x)
 //
+// A compare function must be:
+//   - Deterministic: compare(x, y) == compare(x, y)
+//   - Irreflexive: compare(x, x) == 0
+//   - Transitive: if compare(x, y) < 0 and compare(y, z) < 0, then compare(x, z) < 0
+//   - Total: if x != y, then compare(x, y) != 0
+//
 // SortMaps can be used in conjunction with [EquateEmpty].
-func SortMaps(lessFunc interface{}) cmp.Option {
+func SortMaps(lessOrCompareFunc interface{}) cmp.Option {
-	vf := reflect.ValueOf(lessFunc)
+	vf := reflect.ValueOf(lessOrCompareFunc)
-	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+	if (!function.IsType(vf.Type(), function.Less) && !function.IsType(vf.Type(), function.Compare)) || vf.IsNil() {
-		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+		panic(fmt.Sprintf("invalid less or compare function: %T", lessOrCompareFunc))
 	}
 	ms := mapSorter{vf.Type().In(0), vf}
 	return cmp.FilterValues(ms.filter, cmp.Transformer("cmpopts.SortMaps", ms.sort))
@@ -143,5 +162,10 @@ func (ms mapSorter) checkSort(v reflect.Value) {
 }
 func (ms mapSorter) less(v reflect.Value, i, j int) bool {
 	vx, vy := v.Index(i).Field(0), v.Index(j).Field(0)
-	return ms.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+	vo := ms.fnc.Call([]reflect.Value{vx, vy})[0]
+	if vo.Kind() == reflect.Bool {
+		return vo.Bool()
+	} else {
+		return vo.Int() < 0
+	}
 }

e2e/vendor/github.com/google/go-cmp/cmp/internal/function/func.go

@@ -19,6 +19,7 @@ const (
 
 	tbFunc  // func(T) bool
 	ttbFunc // func(T, T) bool
+	ttiFunc // func(T, T) int
 	trbFunc // func(T, R) bool
 	tibFunc // func(T, I) bool
 	trFunc  // func(T) R
@@ -28,11 +29,13 @@ const (
 	Transformer       = trFunc  // func(T) R
 	ValueFilter       = ttbFunc // func(T, T) bool
 	Less              = ttbFunc // func(T, T) bool
+	Compare           = ttiFunc // func(T, T) int
 	ValuePredicate    = tbFunc  // func(T) bool
 	KeyValuePredicate = trbFunc // func(T, R) bool
 )
 
 var boolType = reflect.TypeOf(true)
+var intType = reflect.TypeOf(0)
 
 // IsType reports whether the reflect.Type is of the specified function type.
 func IsType(t reflect.Type, ft funcType) bool {
@@ -49,6 +52,10 @@ func IsType(t reflect.Type, ft funcType) bool {
 		if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == boolType {
 			return true
 		}
+	case ttiFunc: // func(T, T) int
+		if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == intType {
+			return true
+		}
 	case trbFunc: // func(T, R) bool
 		if ni == 2 && no == 1 && t.Out(0) == boolType {
 			return true

e2e/vendor/github.com/google/go-cmp/cmp/options.go

@@ -232,7 +232,15 @@ func (validator) apply(s *state, vx, vy reflect.Value) {
 		if t := s.curPath.Index(-2).Type(); t.Name() != "" {
 			// Named type with unexported fields.
 			name = fmt.Sprintf("%q.%v", t.PkgPath(), t.Name()) // e.g., "path/to/package".MyType
-			if _, ok := reflect.New(t).Interface().(error); ok {
+			isProtoMessage := func(t reflect.Type) bool {
+				m, ok := reflect.PointerTo(t).MethodByName("ProtoReflect")
+				return ok && m.Type.NumIn() == 1 && m.Type.NumOut() == 1 &&
+					m.Type.Out(0).PkgPath() == "google.golang.org/protobuf/reflect/protoreflect" &&
+					m.Type.Out(0).Name() == "Message"
+			}
+			if isProtoMessage(t) {
+				help = `consider using "google.golang.org/protobuf/testing/protocmp".Transform to compare proto.Message types`
+			} else if _, ok := reflect.New(t).Interface().(error); ok {
 				help = "consider using cmpopts.EquateErrors to compare error values"
 			} else if t.Comparable() {
 				help = "consider using cmpopts.EquateComparable to compare comparable Go types"

e2e/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 2.23.3
+
+### Fixes
+
+- allow `-` as a standalone argument [cfcc1a5]
+- Bug Fix: Add GinkoTBWrapper.Chdir() and GinkoTBWrapper.Context() [feaf292]
+- ignore exit code for symbol test on linux [88e2282]
+
+## 2.23.2
+
+🎉🎉🎉
+
+At long last, some long-standing performance gaps between `ginkgo` and `go test` have been resolved!
+
+Ginkgo operates by running `go test -c` to generate test binaries, and then running those binaries.  It turns out that the compilation step of `go test -c` is slower than `go test`'s compilation step because `go test` strips out debug symbols (`ldflags=-w`) whereas `go test -c` does not.
+
+Ginkgo now passes the appropriate `ldflags` to `go test -c` when running specs to strip out symbols.  This is only done when it is safe to do so and symbols are preferred when profiling is enabled and when `ginkgo build` is called explicitly.
+
+This, coupled, with the [instructions for disabling XProtect on MacOS](https://onsi.github.io/ginkgo/#if-you-are-running-on-macos) yields a much better performance experience with Ginkgo.
+
+## 2.23.1
+
+## 🚨 For users on MacOS 🚨
+
+A long-standing Ginkgo performance issue on MacOS seems to be due to mac's antimalware XProtect.  You can follow the instructions [here](https://onsi.github.io/ginkgo/#if-you-are-running-on-macos) to disable it in your terminal.  Doing so sped up Ginkgo's own test suite from 1m8s to 47s.
+
+### Fixes
+
+Ginkgo's CLI is now a bit clearer if you pass flags in incorrectly:
+
+- make it clearer that you need to pass a filename to the various profile flags, not an absolute directory [a0e52ff]
+- emit an error and exit if the ginkgo invocation includes flags after positional arguments [b799d8d]
+
+This might cause existing CI builds to fail.  If so then it's likely that your CI build was misconfigured and should be corrected.  Open an issue if you need help.
+
 ## 2.23.0
 
 Ginkgo 2.23.0 adds a handful of methods to `GinkgoT()` to make it compatible with the `testing.TB` interface in Go 1.24.  `GinkgoT().Context()`, in particular, is a useful shorthand for generating a new context that will clean itself up in a `DeferCleanup()`.  This has subtle behavior differences from the golang implementation but should make sense in a Ginkgo... um... context.

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go

@@ -44,7 +44,7 @@ func buildSpecs(args []string, cliConfig types.CLIConfig, goFlagsConfig types.Go
 	internal.VerifyCLIAndFrameworkVersion(suites)
 
 	opc := internal.NewOrderedParallelCompiler(cliConfig.ComputedNumCompilers())
-	opc.StartCompiling(suites, goFlagsConfig)
+	opc.StartCompiling(suites, goFlagsConfig, true)
 
 	for {
 		suiteIdx, suite := opc.Next()

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/command.go

@@ -24,7 +24,11 @@ func (c Command) Run(args []string, additionalArgs []string) {
 	if err != nil {
 		AbortWithUsage(err.Error())
 	}
-
+	for _, arg := range args {
+		if len(arg) > 1 && strings.HasPrefix(arg, "-") {
+			AbortWith(types.GinkgoErrors.FlagAfterPositionalParameter().Error())
+		}
+	}
 	c.Command(args, additionalArgs)
 }
 

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/compile.go

@@ -11,7 +11,7 @@ import (
 	"github.com/onsi/ginkgo/v2/types"
 )
 
-func CompileSuite(suite TestSuite, goFlagsConfig types.GoFlagsConfig) TestSuite {
+func CompileSuite(suite TestSuite, goFlagsConfig types.GoFlagsConfig, preserveSymbols bool) TestSuite {
 	if suite.PathToCompiledTest != "" {
 		return suite
 	}
@@ -46,7 +46,7 @@ func CompileSuite(suite TestSuite, goFlagsConfig types.GoFlagsConfig) TestSuite
 		suite.CompilationError = fmt.Errorf("Failed to get relative path from package to the current working directory:\n%s", err.Error())
 		return suite
 	}
-	args, err := types.GenerateGoTestCompileArgs(goFlagsConfig, "./", pathToInvocationPath)
+	args, err := types.GenerateGoTestCompileArgs(goFlagsConfig, "./", pathToInvocationPath, preserveSymbols)
 	if err != nil {
 		suite.State = TestSuiteStateFailedToCompile
 		suite.CompilationError = fmt.Errorf("Failed to generate go test compile flags:\n%s", err.Error())
@@ -120,7 +120,7 @@ func NewOrderedParallelCompiler(numCompilers int) *OrderedParallelCompiler {
 	}
 }
 
-func (opc *OrderedParallelCompiler) StartCompiling(suites TestSuites, goFlagsConfig types.GoFlagsConfig) {
+func (opc *OrderedParallelCompiler) StartCompiling(suites TestSuites, goFlagsConfig types.GoFlagsConfig, preserveSymbols bool) {
 	opc.stopped = false
 	opc.idx = 0
 	opc.numSuites = len(suites)
@@ -135,7 +135,7 @@ func (opc *OrderedParallelCompiler) StartCompiling(suites TestSuites, goFlagsCon
 				stopped := opc.stopped
 				opc.mutex.Unlock()
 				if !stopped {
-					suite = CompileSuite(suite, goFlagsConfig)
+					suite = CompileSuite(suite, goFlagsConfig, preserveSymbols)
 				}
 				c <- suite
 			}

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo/run/run_command.go

@@ -107,7 +107,7 @@ OUTER_LOOP:
 		}
 
 		opc := internal.NewOrderedParallelCompiler(r.cliConfig.ComputedNumCompilers())
-		opc.StartCompiling(suites, r.goFlagsConfig)
+		opc.StartCompiling(suites, r.goFlagsConfig, false)
 
 	SUITE_LOOP:
 		for {

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo/watch/watch_command.go

@@ -153,7 +153,7 @@ func (w *SpecWatcher) WatchSpecs(args []string, additionalArgs []string) {
 }
 
 func (w *SpecWatcher) compileAndRun(suite internal.TestSuite, additionalArgs []string) internal.TestSuite {
-	suite = internal.CompileSuite(suite, w.goFlagsConfig)
+	suite = internal.CompileSuite(suite, w.goFlagsConfig, false)
 	if suite.State.Is(internal.TestSuiteStateFailedToCompile) {
 		fmt.Println(suite.CompilationError.Error())
 		return suite

e2e/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go

@@ -130,6 +130,12 @@ type GinkgoTBWrapper struct {
 func (g *GinkgoTBWrapper) Cleanup(f func()) {
 	g.GinkgoT.Cleanup(f)
 }
+func (g *GinkgoTBWrapper) Chdir(dir string) {
+	g.GinkgoT.Chdir(dir)
+}
+func (g *GinkgoTBWrapper) Context() context.Context {
+	return g.GinkgoT.Context()
+}
 func (g *GinkgoTBWrapper) Error(args ...any) {
 	g.GinkgoT.Error(args...)
 }

e2e/vendor/github.com/onsi/ginkgo/v2/types/config.go

@@ -231,6 +231,10 @@ func (g GoFlagsConfig) BinaryMustBePreserved() bool {
 	return g.BlockProfile != "" || g.CPUProfile != "" || g.MemProfile != "" || g.MutexProfile != ""
 }
 
+func (g GoFlagsConfig) NeedsSymbols() bool {
+	return g.BinaryMustBePreserved()
+}
+
 // Configuration that were deprecated in 2.0
 type deprecatedConfig struct {
 	DebugParallel                   bool
@@ -257,8 +261,12 @@ var FlagSections = GinkgoFlagSections{
 	{Key: "filter", Style: "{{cyan}}", Heading: "Filtering Tests"},
 	{Key: "failure", Style: "{{red}}", Heading: "Failure Handling"},
 	{Key: "output", Style: "{{magenta}}", Heading: "Controlling Output Formatting"},
-	{Key: "code-and-coverage-analysis", Style: "{{orange}}", Heading: "Code and Coverage Analysis"},
+	{Key: "code-and-coverage-analysis", Style: "{{orange}}", Heading: "Code and Coverage Analysis",
-	{Key: "performance-analysis", Style: "{{coral}}", Heading: "Performance Analysis"},
+		Description: "When generating a cover files, please pass a filename {{bold}}not{{/}} a path.  To specify a different directory use {{magenta}}--output-dir{{/}}.",
+	},
+	{Key: "performance-analysis", Style: "{{coral}}", Heading: "Performance Analysis",
+		Description: "When generating profile files, please pass filenames {{bold}}not{{/}} a path.  Ginkgo will generate a profile file with the given name in the package's directory.  To specify a different directory use {{magenta}}--output-dir{{/}}.",
+	},
 	{Key: "debug", Style: "{{blue}}", Heading: "Debugging Tests",
 		Description: "In addition to these flags, Ginkgo supports a few debugging environment variables.  To change the parallel server protocol set {{blue}}GINKGO_PARALLEL_PROTOCOL{{/}} to {{bold}}HTTP{{/}}.  To avoid pruning callstacks set {{blue}}GINKGO_PRUNE_STACK{{/}} to {{bold}}FALSE{{/}}."},
 	{Key: "watch", Style: "{{light-yellow}}", Heading: "Controlling Ginkgo Watch"},
@@ -572,7 +580,7 @@ var GoBuildFlags = GinkgoFlags{
 // GoRunFlags provides flags for the Ginkgo CLI  run, and watch commands that capture go's run-time flags.  These are passed to the compiled test binary by the ginkgo CLI
 var GoRunFlags = GinkgoFlags{
 	{KeyPath: "Go.CoverProfile", Name: "coverprofile", UsageArgument: "file", SectionKey: "code-and-coverage-analysis",
-		Usage: `Write a coverage profile to the file after all tests have passed. Sets -cover.`},
+		Usage: `Write a coverage profile to the file after all tests have passed. Sets -cover.  Must be passed a filename, not a path.  Use output-dir to control the location of the output.`},
 	{KeyPath: "Go.BlockProfile", Name: "blockprofile", UsageArgument: "file", SectionKey: "performance-analysis",
 		Usage: `Write a goroutine blocking profile to the specified file when all tests are complete. Preserves test binary.`},
 	{KeyPath: "Go.BlockProfileRate", Name: "blockprofilerate", UsageArgument: "rate", SectionKey: "performance-analysis",
@@ -600,6 +608,22 @@ func VetAndInitializeCLIAndGoConfig(cliConfig CLIConfig, goFlagsConfig GoFlagsCo
 		errors = append(errors, GinkgoErrors.BothRepeatAndUntilItFails())
 	}
 
+	if strings.ContainsRune(goFlagsConfig.CoverProfile, os.PathSeparator) {
+		errors = append(errors, GinkgoErrors.ExpectFilenameNotPath("--coverprofile", goFlagsConfig.CoverProfile))
+	}
+	if strings.ContainsRune(goFlagsConfig.CPUProfile, os.PathSeparator) {
+		errors = append(errors, GinkgoErrors.ExpectFilenameNotPath("--cpuprofile", goFlagsConfig.CPUProfile))
+	}
+	if strings.ContainsRune(goFlagsConfig.MemProfile, os.PathSeparator) {
+		errors = append(errors, GinkgoErrors.ExpectFilenameNotPath("--memprofile", goFlagsConfig.MemProfile))
+	}
+	if strings.ContainsRune(goFlagsConfig.BlockProfile, os.PathSeparator) {
+		errors = append(errors, GinkgoErrors.ExpectFilenameNotPath("--blockprofile", goFlagsConfig.BlockProfile))
+	}
+	if strings.ContainsRune(goFlagsConfig.MutexProfile, os.PathSeparator) {
+		errors = append(errors, GinkgoErrors.ExpectFilenameNotPath("--mutexprofile", goFlagsConfig.MutexProfile))
+	}
+
 	//initialize the output directory
 	if cliConfig.OutputDir != "" {
 		err := os.MkdirAll(cliConfig.OutputDir, 0777)
@@ -620,7 +644,7 @@ func VetAndInitializeCLIAndGoConfig(cliConfig CLIConfig, goFlagsConfig GoFlagsCo
 }
 
 // GenerateGoTestCompileArgs is used by the Ginkgo CLI to generate command line arguments to pass to the go test -c command when compiling the test
-func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild string, pathToInvocationPath string) ([]string, error) {
+func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild string, pathToInvocationPath string, preserveSymbols bool) ([]string, error) {
 	// if the user has set the CoverProfile run-time flag make sure to set the build-time cover flag to make sure
 	// the built test binary can generate a coverprofile
 	if goFlagsConfig.CoverProfile != "" {
@@ -643,6 +667,10 @@ func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild strin
 		goFlagsConfig.CoverPkg = strings.Join(adjustedCoverPkgs, ",")
 	}
 
+	if !goFlagsConfig.NeedsSymbols() && goFlagsConfig.LDFlags == "" && !preserveSymbols {
+		goFlagsConfig.LDFlags = "-w -s"
+	}
+
 	args := []string{"test", "-c", packageToBuild}
 	goArgs, err := GenerateFlagArgs(
 		GoBuildFlags,

e2e/vendor/github.com/onsi/ginkgo/v2/types/errors.go

@@ -629,6 +629,20 @@ func (g ginkgoErrors) BothRepeatAndUntilItFails() error {
 	}
 }
 
+func (g ginkgoErrors) ExpectFilenameNotPath(flag string, path string) error {
+	return GinkgoError{
+		Heading: fmt.Sprintf("%s expects a filename but was given a path: %s", flag, path),
+		Message: fmt.Sprintf("%s takes a filename, not a path.  Use --output-dir to specify a directory to collect all test outputs.", flag),
+	}
+}
+
+func (g ginkgoErrors) FlagAfterPositionalParameter() error {
+	return GinkgoError{
+		Heading: "Malformed arguments - detected a flag after the package liste",
+		Message: "Make sure all flags appear {{bold}}after{{/}} the Ginkgo subcommand and {{bold}}before{{/}} your list of packages (or './...').\n{{gray}}e.g. 'ginkgo run -p my_package' is valid but `ginkgo -p run my_package` is not.\n{{gray}}e.g. 'ginkgo -p -vet ./...' is valid but 'ginkgo -p ./... -vet' is not{{/}}",
+	}
+}
+
 /* Stack-Trace parsing errors */
 
 func (g ginkgoErrors) FailedToParseStackTrace(message string) error {

e2e/vendor/github.com/onsi/ginkgo/v2/types/version.go

@@ -1,3 +1,3 @@
 package types
 
-const VERSION = "2.23.0"
+const VERSION = "2.23.3"

e2e/vendor/github.com/onsi/gomega/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 1.36.3
+
+### Maintenance
+
+- bump all the things [adb8b49]
+- chore: replace `interface{}` with `any` [7613216]
+- Bump google.golang.org/protobuf from 1.36.1 to 1.36.5 (#822) [9fe5259]
+- remove spurious "toolchain" from go.mod (#819) [a0e85b9]
+- Bump golang.org/x/net from 0.33.0 to 0.35.0 (#823) [604a8b1]
+- Bump activesupport from 6.0.6.1 to 6.1.7.5 in /docs (#772) [36fbc84]
+- Bump github-pages from 231 to 232 in /docs (#778) [ced70d7]
+- Bump rexml from 3.2.6 to 3.3.9 in /docs (#788) [c8b4a07]
+- Bump github.com/onsi/ginkgo/v2 from 2.22.1 to 2.22.2 (#812) [06431b9]
+- Bump webrick from 1.8.1 to 1.9.1 in /docs (#800) [b55a92d]
+- Fix typos (#813) [a1d518b]
+
 ## 1.36.2
 
 ### Maintenance
@@ -322,7 +338,7 @@ Require Go 1.22+
 
 ### Features
 
-Introducting [gcustom](https://onsi.github.io/gomega/#gcustom-a-convenient-mechanism-for-buildling-custom-matchers) - a convenient mechanism for building custom matchers.
+Introducing [gcustom](https://onsi.github.io/gomega/#gcustom-a-convenient-mechanism-for-buildling-custom-matchers) - a convenient mechanism for building custom matchers.
 
 This is an RC release for `gcustom`.  The external API may be tweaked in response to feedback however it is expected to remain mostly stable.
 
@@ -461,7 +477,7 @@ These improvements are all documented in [Gomega's docs](https://onsi.github.io/
 - Fix max number of samples in experiments on non-64-bit systems. (#528) [1c84497]
 - Remove dependency on ginkgo v1.16.4 (#530) [4dea8d5]
 - Fix for Go 1.18 (#532) [56d2a29]
-- Document precendence of timeouts (#533) [b607941]
+- Document precedence of timeouts (#533) [b607941]
 
 ## 1.18.1
 
@@ -478,7 +494,7 @@ These improvements are all documented in [Gomega's docs](https://onsi.github.io/
 ## Fixes
 - Gomega now uses ioutil for Go 1.15 and lower (#492) - official support is only for the most recent two major versions of Go but this will unblock users who need to stay on older unsupported versions of Go. [c29c1c0]
 
-## Maintenace
+## Maintenance
 - Remove Travis workflow (#491) [72e6040]
 - Upgrade to Ginkgo 2.0.0 GA [f383637]
 - chore: fix description of HaveField matcher (#487) [2b4b2c0]
@@ -726,7 +742,7 @@ Improvements:
 
 - Added `BeSent` which attempts to send a value down a channel and fails if the attempt blocks.  Can be paired with `Eventually` to safely send a value down a channel with a timeout.
 - `Ω`, `Expect`, `Eventually`, and `Consistently` now immediately `panic` if there is no registered fail handler.  This is always a mistake that can hide failing tests.
-- `Receive()` no longer errors when passed a closed channel, it's perfectly fine to attempt to read from a closed channel so Ω(c).Should(Receive()) always fails and Ω(c).ShoudlNot(Receive()) always passes with a closed channel.
+- `Receive()` no longer errors when passed a closed channel, it's perfectly fine to attempt to read from a closed channel so Ω(c).Should(Receive()) always fails and Ω(c).ShouldNot(Receive()) always passes with a closed channel.
 - Added `HavePrefix` and `HaveSuffix` matchers.
 - `ghttp` can now handle concurrent requests.
 - Added `Succeed` which allows one to write `Ω(MyFunction()).Should(Succeed())`.
@@ -736,7 +752,7 @@ Improvements:
 - `ghttp` servers can take an `io.Writer`.  `ghttp` will write a line to the writer when each request arrives.
 - Added `WithTransform` matcher to allow munging input data before feeding into the relevant matcher
 - Added boolean `And`, `Or`, and `Not` matchers to allow creating composite matchers
-- Added `gbytes.TimeoutCloser`, `gbytes.TimeoutReader`, and `gbytes.TimeoutWriter` - these are convenience wrappers that timeout if the underlying Closer/Reader/Writer does not return within the alloted time.
+- Added `gbytes.TimeoutCloser`, `gbytes.TimeoutReader`, and `gbytes.TimeoutWriter` - these are convenience wrappers that timeout if the underlying Closer/Reader/Writer does not return within the allotted time.
 - Added `gbytes.BufferReader` - this constructs a `gbytes.Buffer` that asynchronously reads the passed-in `io.Reader` into its buffer.
 
 Bug Fixes:
@@ -781,7 +797,7 @@ New Matchers:
 
 Updated Matchers:
 
-- `Receive` matcher can take a matcher as an argument and passes only if the channel under test receives an objet that satisfies the passed-in matcher.
+- `Receive` matcher can take a matcher as an argument and passes only if the channel under test receives an object that satisfies the passed-in matcher.
 - Matchers that implement `MatchMayChangeInTheFuture(actual interface{}) bool` can inform `Eventually` and/or `Consistently` when a match has no chance of changing status in the future.  For example, `Receive` returns `false` when a channel is closed.
 
 Misc:

e2e/vendor/github.com/onsi/gomega/format/format.go

@@ -57,7 +57,7 @@ var Indent = "    "
 
 var longFormThreshold = 20
 
-// GomegaStringer allows for custom formating of objects for gomega.
+// GomegaStringer allows for custom formatting of objects for gomega.
 type GomegaStringer interface {
 	// GomegaString will be used to custom format an object.
 	// It does not follow UseStringerRepresentation value and will always be called regardless.
@@ -73,7 +73,7 @@ If the CustomFormatter does not want to handle the object it should return ("",
 
 Strings returned by CustomFormatters are not truncated
 */
-type CustomFormatter func(value interface{}) (string, bool)
+type CustomFormatter func(value any) (string, bool)
 type CustomFormatterKey uint
 
 var customFormatterKey CustomFormatterKey = 1
@@ -125,7 +125,7 @@ If expected is omitted, then the message looks like:
 		<pretty printed actual>
 	<message>
 */
-func Message(actual interface{}, message string, expected ...interface{}) string {
+func Message(actual any, message string, expected ...any) string {
 	if len(expected) == 0 {
 		return fmt.Sprintf("Expected\n%s\n%s", Object(actual, 1), message)
 	}
@@ -255,7 +255,7 @@ recursing into the object.
 
 Set PrintContextObjects to true to print the content of objects implementing context.Context
 */
-func Object(object interface{}, indentation uint) string {
+func Object(object any, indentation uint) string {
 	indent := strings.Repeat(Indent, int(indentation))
 	value := reflect.ValueOf(object)
 	commonRepresentation := ""
@@ -392,7 +392,7 @@ func formatValue(value reflect.Value, indentation uint) string {
 	}
 }
 
-func formatString(object interface{}, indentation uint) string {
+func formatString(object any, indentation uint) string {
 	if indentation == 1 {
 		s := fmt.Sprintf("%s", object)
 		components := strings.Split(s, "\n")

e2e/vendor/github.com/onsi/gomega/gcustom/make_matcher.go

@@ -12,7 +12,7 @@ import (
 	"github.com/onsi/gomega/format"
 )
 
-var interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
+var interfaceType = reflect.TypeOf((*any)(nil)).Elem()
 var errInterface = reflect.TypeOf((*error)(nil)).Elem()
 
 var defaultTemplate = template.Must(ParseTemplate("{{if .Failure}}Custom matcher failed for:{{else}}Custom matcher succeeded (but was expected to fail) for:{{end}}\n{{.FormattedActual}}"))
@@ -191,7 +191,7 @@ func (c CustomGomegaMatcher) WithTemplate(templ string, data ...any) CustomGomeg
 /*
 WithPrecompiledTemplate returns a CustomGomegaMatcher configured to use the passed-in template.  The template should be precompiled with gcustom.ParseTemplate().
 
-As with WithTemplate() you can provide a single pice of additional data as an optional argument.  This is accessed in the template via {{.Data}}
+As with WithTemplate() you can provide a single piece of additional data as an optional argument.  This is accessed in the template via {{.Data}}
 */
 func (c CustomGomegaMatcher) WithPrecompiledTemplate(templ *template.Template, data ...any) CustomGomegaMatcher {
 	c.templateMessage = templ

e2e/vendor/github.com/onsi/gomega/gomega_dsl.go

@@ -22,7 +22,7 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-const GOMEGA_VERSION = "1.36.2"
+const GOMEGA_VERSION = "1.36.3"
 
 const nilGomegaPanic = `You are trying to make an assertion, but haven't registered Gomega's fail handler.
 If you're using Ginkgo then you probably forgot to put your assertion in an It().
@@ -191,7 +191,7 @@ func ensureDefaultGomegaIsConfigured() {
 // Will succeed only if `MyAmazingThing()` returns `(3, nil)`
 //
 // Ω and Expect are identical
-func Ω(actual interface{}, extra ...interface{}) Assertion {
+func Ω(actual any, extra ...any) Assertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.Ω(actual, extra...)
 }
@@ -217,7 +217,7 @@ func Ω(actual interface{}, extra ...interface{}) Assertion {
 // Will succeed only if `MyAmazingThing()` returns `(3, nil)`
 //
 // Expect and Ω are identical
-func Expect(actual interface{}, extra ...interface{}) Assertion {
+func Expect(actual any, extra ...any) Assertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.Expect(actual, extra...)
 }
@@ -233,7 +233,7 @@ func Expect(actual interface{}, extra ...interface{}) Assertion {
 // This is most useful in helper functions that make assertions.  If you want Gomega's
 // error message to refer to the calling line in the test (as opposed to the line in the helper function)
 // set the first argument of `ExpectWithOffset` appropriately.
-func ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Assertion {
+func ExpectWithOffset(offset int, actual any, extra ...any) Assertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.ExpectWithOffset(offset, actual, extra...)
 }
@@ -319,19 +319,19 @@ you an also use Eventually().WithContext(ctx) to pass in the context.  Passed-in
 		Eventually(client.FetchCount).WithContext(ctx).WithArguments("/users").Should(BeNumerically(">=", 17))
 	}, SpecTimeout(time.Second))
 
-Either way the context pasesd to Eventually is also passed to the underlying function.  Now, when Ginkgo cancels the context both the FetchCount client and Gomega will be informed and can exit.
+Either way the context passed to Eventually is also passed to the underlying function.  Now, when Ginkgo cancels the context both the FetchCount client and Gomega will be informed and can exit.
 
 By default, when a context is passed to Eventually *without* an explicit timeout, Gomega will rely solely on the context's cancellation to determine when to stop polling.  If you want to specify a timeout in addition to the context you can do so using the .WithTimeout() method.  For example:
 
 	Eventually(client.FetchCount).WithContext(ctx).WithTimeout(10*time.Second).Should(BeNumerically(">=", 17))
 
-now either the context cacnellation or the timeout will cause Eventually to stop polling.
+now either the context cancellation or the timeout will cause Eventually to stop polling.
 
 If, instead, you would like to opt out of this behavior and have Gomega's default timeouts govern Eventuallys that take a context you can call:
 
 	EnforceDefaultTimeoutsWhenUsingContexts()
 
-in the DSL (or on a Gomega instance).  Now all calls to Eventually that take a context will fail if eitehr the context is cancelled or the default timeout elapses.
+in the DSL (or on a Gomega instance).  Now all calls to Eventually that take a context will fail if either the context is cancelled or the default timeout elapses.
 
 **Category 3: Making assertions _in_ the function passed into Eventually**
 
@@ -390,7 +390,7 @@ is equivalent to
 
 	Eventually(...).WithTimeout(10*time.Second).WithPolling(2*time.Second).WithContext(ctx).Should(...)
 */
-func Eventually(actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
+func Eventually(actualOrCtx any, args ...any) AsyncAssertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.Eventually(actualOrCtx, args...)
 }
@@ -404,7 +404,7 @@ func Eventually(actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
 // `EventuallyWithOffset` specifying a timeout interval (and an optional polling interval) are
 // the same as `Eventually(...).WithOffset(...).WithTimeout` or
 // `Eventually(...).WithOffset(...).WithTimeout(...).WithPolling`.
-func EventuallyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
+func EventuallyWithOffset(offset int, actualOrCtx any, args ...any) AsyncAssertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.EventuallyWithOffset(offset, actualOrCtx, args...)
 }
@@ -424,7 +424,7 @@ Consistently is useful in cases where you want to assert that something *does no
 
 This will block for 200 milliseconds and repeatedly check the channel and ensure nothing has been received.
 */
-func Consistently(actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
+func Consistently(actualOrCtx any, args ...any) AsyncAssertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.Consistently(actualOrCtx, args...)
 }
@@ -435,13 +435,13 @@ func Consistently(actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
 //
 // `ConsistentlyWithOffset` is the same as `Consistently(...).WithOffset` and
 // optional `WithTimeout` and `WithPolling`.
-func ConsistentlyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) AsyncAssertion {
+func ConsistentlyWithOffset(offset int, actualOrCtx any, args ...any) AsyncAssertion {
 	ensureDefaultGomegaIsConfigured()
 	return Default.ConsistentlyWithOffset(offset, actualOrCtx, args...)
 }
 
 /*
-StopTrying can be used to signal to Eventually and Consistentlythat they should abort and stop trying.  This always results in a failure of the assertion - and the failure message is the content of the StopTrying signal.
+StopTrying can be used to signal to Eventually and Consistently that they should abort and stop trying.  This always results in a failure of the assertion - and the failure message is the content of the StopTrying signal.
 
 You can send the StopTrying signal by either returning StopTrying("message") as an error from your passed-in function _or_ by calling StopTrying("message").Now() to trigger a panic and end execution.
 

e2e/vendor/github.com/onsi/gomega/internal/assertion.go

@@ -9,7 +9,7 @@ import (
 )
 
 type Assertion struct {
-	actuals     []interface{} // actual value plus all extra values
+	actuals     []any    // actual value plus all extra values
 	actualIndex int      // value to pass to the matcher
 	vet         vetinari // the vet to call before calling Gomega matcher
 	offset      int
@@ -17,11 +17,11 @@ type Assertion struct {
 }
 
 // ...obligatory discworld reference, as "vetineer" doesn't sound ... quite right.
-type vetinari func(assertion *Assertion, optionalDescription ...interface{}) bool
+type vetinari func(assertion *Assertion, optionalDescription ...any) bool
 
-func NewAssertion(actualInput interface{}, g *Gomega, offset int, extra ...interface{}) *Assertion {
+func NewAssertion(actualInput any, g *Gomega, offset int, extra ...any) *Assertion {
 	return &Assertion{
-		actuals:     append([]interface{}{actualInput}, extra...),
+		actuals:     append([]any{actualInput}, extra...),
 		actualIndex: 0,
 		vet:         (*Assertion).vetActuals,
 		offset:      offset,
@@ -44,37 +44,37 @@ func (assertion *Assertion) Error() types.Assertion {
 	}
 }
 
-func (assertion *Assertion) Should(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) Should(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Assertion", optionalDescription...)
 	return assertion.vet(assertion, optionalDescription...) && assertion.match(matcher, true, optionalDescription...)
 }
 
-func (assertion *Assertion) ShouldNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) ShouldNot(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Assertion", optionalDescription...)
 	return assertion.vet(assertion, optionalDescription...) && assertion.match(matcher, false, optionalDescription...)
 }
 
-func (assertion *Assertion) To(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) To(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Assertion", optionalDescription...)
 	return assertion.vet(assertion, optionalDescription...) && assertion.match(matcher, true, optionalDescription...)
 }
 
-func (assertion *Assertion) ToNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) ToNot(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Assertion", optionalDescription...)
 	return assertion.vet(assertion, optionalDescription...) && assertion.match(matcher, false, optionalDescription...)
 }
 
-func (assertion *Assertion) NotTo(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) NotTo(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Assertion", optionalDescription...)
 	return assertion.vet(assertion, optionalDescription...) && assertion.match(matcher, false, optionalDescription...)
 }
 
-func (assertion *Assertion) buildDescription(optionalDescription ...interface{}) string {
+func (assertion *Assertion) buildDescription(optionalDescription ...any) string {
 	switch len(optionalDescription) {
 	case 0:
 		return ""
@@ -86,7 +86,7 @@ func (assertion *Assertion) buildDescription(optionalDescription ...interface{})
 	return fmt.Sprintf(optionalDescription[0].(string), optionalDescription[1:]...) + "\n"
 }
 
-func (assertion *Assertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...interface{}) bool {
+func (assertion *Assertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...any) bool {
 	actualInput := assertion.actuals[assertion.actualIndex]
 	matches, err := matcher.Match(actualInput)
 	assertion.g.THelper()
@@ -113,7 +113,7 @@ func (assertion *Assertion) match(matcher types.GomegaMatcher, desiredMatch bool
 // vetActuals vets the actual values, with the (optional) exception of a
 // specific value, such as the first value in case non-error assertions, or the
 // last value in case of Error()-based assertions.
-func (assertion *Assertion) vetActuals(optionalDescription ...interface{}) bool {
+func (assertion *Assertion) vetActuals(optionalDescription ...any) bool {
 	success, message := vetActuals(assertion.actuals, assertion.actualIndex)
 	if success {
 		return true
@@ -129,7 +129,7 @@ func (assertion *Assertion) vetActuals(optionalDescription ...interface{}) bool
 // the final error value is non-zero. Otherwise, it doesn't vet the actual
 // values, as these are allowed to take on any values unless there is a non-zero
 // error value.
-func (assertion *Assertion) vetError(optionalDescription ...interface{}) bool {
+func (assertion *Assertion) vetError(optionalDescription ...any) bool {
 	if err := assertion.actuals[assertion.actualIndex]; err != nil {
 		// Go error result idiom: all other actual values must be zero values.
 		return assertion.vetActuals(optionalDescription...)
@@ -139,7 +139,7 @@ func (assertion *Assertion) vetError(optionalDescription ...interface{}) bool {
 
 // vetActuals vets a slice of actual values, optionally skipping a particular
 // value slice element, such as the first or last value slice element.
-func vetActuals(actuals []interface{}, skipIndex int) (bool, string) {
+func vetActuals(actuals []any, skipIndex int) (bool, string) {
 	for i, actual := range actuals {
 		if i == skipIndex {
 			continue

e2e/vendor/github.com/onsi/gomega/internal/async_assertion.go

@@ -69,8 +69,8 @@ type AsyncAssertion struct {
 	asyncType AsyncAssertionType
 
 	actualIsFunc  bool
-	actual        interface{}
+	actual        any
-	argsToForward []interface{}
+	argsToForward []any
 
 	timeoutInterval    time.Duration
 	pollingInterval    time.Duration
@@ -80,7 +80,7 @@ type AsyncAssertion struct {
 	g                  *Gomega
 }
 
-func NewAsyncAssertion(asyncType AsyncAssertionType, actualInput interface{}, g *Gomega, timeoutInterval time.Duration, pollingInterval time.Duration, mustPassRepeatedly int, ctx context.Context, offset int) *AsyncAssertion {
+func NewAsyncAssertion(asyncType AsyncAssertionType, actualInput any, g *Gomega, timeoutInterval time.Duration, pollingInterval time.Duration, mustPassRepeatedly int, ctx context.Context, offset int) *AsyncAssertion {
 	out := &AsyncAssertion{
 		asyncType:          asyncType,
 		timeoutInterval:    timeoutInterval,
@@ -129,7 +129,7 @@ func (assertion *AsyncAssertion) WithContext(ctx context.Context) types.AsyncAss
 	return assertion
 }
 
-func (assertion *AsyncAssertion) WithArguments(argsToForward ...interface{}) types.AsyncAssertion {
+func (assertion *AsyncAssertion) WithArguments(argsToForward ...any) types.AsyncAssertion {
 	assertion.argsToForward = argsToForward
 	return assertion
 }
@@ -139,19 +139,19 @@ func (assertion *AsyncAssertion) MustPassRepeatedly(count int) types.AsyncAssert
 	return assertion
 }
 
-func (assertion *AsyncAssertion) Should(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *AsyncAssertion) Should(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Asynchronous assertion", optionalDescription...)
 	return assertion.match(matcher, true, optionalDescription...)
 }
 
-func (assertion *AsyncAssertion) ShouldNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+func (assertion *AsyncAssertion) ShouldNot(matcher types.GomegaMatcher, optionalDescription ...any) bool {
 	assertion.g.THelper()
 	vetOptionalDescription("Asynchronous assertion", optionalDescription...)
 	return assertion.match(matcher, false, optionalDescription...)
 }
 
-func (assertion *AsyncAssertion) buildDescription(optionalDescription ...interface{}) string {
+func (assertion *AsyncAssertion) buildDescription(optionalDescription ...any) string {
 	switch len(optionalDescription) {
 	case 0:
 		return ""
@@ -163,7 +163,7 @@ func (assertion *AsyncAssertion) buildDescription(optionalDescription ...interfa
 	return fmt.Sprintf(optionalDescription[0].(string), optionalDescription[1:]...) + "\n"
 }
 
-func (assertion *AsyncAssertion) processReturnValues(values []reflect.Value) (interface{}, error) {
+func (assertion *AsyncAssertion) processReturnValues(values []reflect.Value) (any, error) {
 	if len(values) == 0 {
 		return nil, &asyncPolledActualError{
 			message: fmt.Sprintf("The function passed to %s did not return any values", assertion.asyncType),
@@ -224,7 +224,7 @@ func (assertion *AsyncAssertion) argumentMismatchError(t reflect.Type, numProvid
 	if numProvided == 1 {
 		have = "has"
 	}
-	return fmt.Errorf(`The function passed to %s has signature %s takes %d arguments but %d %s been provided.  Please use %s().WithArguments() to pass the corect set of arguments.
+	return fmt.Errorf(`The function passed to %s has signature %s takes %d arguments but %d %s been provided.  Please use %s().WithArguments() to pass the correct set of arguments.
 
 You can learn more at https://onsi.github.io/gomega/#eventually
 `, assertion.asyncType, t, t.NumIn(), numProvided, have, assertion.asyncType)
@@ -237,9 +237,9 @@ You can learn more at https://onsi.github.io/gomega/#eventually
 `, assertion.asyncType, reason)
 }
 
-func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error), error) {
+func (assertion *AsyncAssertion) buildActualPoller() (func() (any, error), error) {
 	if !assertion.actualIsFunc {
-		return func() (interface{}, error) { return assertion.actual, nil }, nil
+		return func() (any, error) { return assertion.actual, nil }, nil
 	}
 	actualValue := reflect.ValueOf(assertion.actual)
 	actualType := reflect.TypeOf(assertion.actual)
@@ -301,7 +301,7 @@ func (assertion *AsyncAssertion) buildActualPoller() (func() (interface{}, error
 		return nil, assertion.invalidMustPassRepeatedlyError("parameter can't be < 1")
 	}
 
-	return func() (actual interface{}, err error) {
+	return func() (actual any, err error) {
 		var values []reflect.Value
 		assertionFailure = nil
 		defer func() {
@@ -354,14 +354,14 @@ func (assertion *AsyncAssertion) afterPolling() <-chan time.Time {
 	}
 }
 
-func (assertion *AsyncAssertion) matcherSaysStopTrying(matcher types.GomegaMatcher, value interface{}) bool {
+func (assertion *AsyncAssertion) matcherSaysStopTrying(matcher types.GomegaMatcher, value any) bool {
 	if assertion.actualIsFunc || types.MatchMayChangeInTheFuture(matcher, value) {
 		return false
 	}
 	return true
 }
 
-func (assertion *AsyncAssertion) pollMatcher(matcher types.GomegaMatcher, value interface{}) (matches bool, err error) {
+func (assertion *AsyncAssertion) pollMatcher(matcher types.GomegaMatcher, value any) (matches bool, err error) {
 	defer func() {
 		if e := recover(); e != nil {
 			if _, isAsyncError := AsPollingSignalError(e); isAsyncError {
@@ -377,13 +377,13 @@ func (assertion *AsyncAssertion) pollMatcher(matcher types.GomegaMatcher, value
 	return
 }
 
-func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...interface{}) bool {
+func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...any) bool {
 	timer := time.Now()
 	timeout := assertion.afterTimeout()
 	lock := sync.Mutex{}
 
 	var matches, hasLastValidActual bool
-	var actual, lastValidActual interface{}
+	var actual, lastValidActual any
 	var actualErr, matcherErr error
 	var oracleMatcherSaysStop bool
 

e2e/vendor/github.com/onsi/gomega/internal/duration_bundle.go

@@ -49,7 +49,7 @@ func durationFromEnv(key string, defaultDuration time.Duration) time.Duration {
 	return duration
 }
 
-func toDuration(input interface{}) (time.Duration, error) {
+func toDuration(input any) (time.Duration, error) {
 	duration, ok := input.(time.Duration)
 	if ok {
 		return duration, nil

e2e/vendor/github.com/onsi/gomega/internal/gomega.go

@@ -40,45 +40,45 @@ func (g *Gomega) ConfigureWithT(t types.GomegaTestingT) *Gomega {
 	return g
 }
 
-func (g *Gomega) Ω(actual interface{}, extra ...interface{}) types.Assertion {
+func (g *Gomega) Ω(actual any, extra ...any) types.Assertion {
 	return g.ExpectWithOffset(0, actual, extra...)
 }
 
-func (g *Gomega) Expect(actual interface{}, extra ...interface{}) types.Assertion {
+func (g *Gomega) Expect(actual any, extra ...any) types.Assertion {
 	return g.ExpectWithOffset(0, actual, extra...)
 }
 
-func (g *Gomega) ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) types.Assertion {
+func (g *Gomega) ExpectWithOffset(offset int, actual any, extra ...any) types.Assertion {
 	return NewAssertion(actual, g, offset, extra...)
 }
 
-func (g *Gomega) Eventually(actualOrCtx interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) Eventually(actualOrCtx any, args ...any) types.AsyncAssertion {
 	return g.makeAsyncAssertion(AsyncAssertionTypeEventually, 0, actualOrCtx, args...)
 }
 
-func (g *Gomega) EventuallyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) EventuallyWithOffset(offset int, actualOrCtx any, args ...any) types.AsyncAssertion {
 	return g.makeAsyncAssertion(AsyncAssertionTypeEventually, offset, actualOrCtx, args...)
 }
 
-func (g *Gomega) Consistently(actualOrCtx interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) Consistently(actualOrCtx any, args ...any) types.AsyncAssertion {
 	return g.makeAsyncAssertion(AsyncAssertionTypeConsistently, 0, actualOrCtx, args...)
 }
 
-func (g *Gomega) ConsistentlyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) ConsistentlyWithOffset(offset int, actualOrCtx any, args ...any) types.AsyncAssertion {
 	return g.makeAsyncAssertion(AsyncAssertionTypeConsistently, offset, actualOrCtx, args...)
 }
 
-func (g *Gomega) makeAsyncAssertion(asyncAssertionType AsyncAssertionType, offset int, actualOrCtx interface{}, args ...interface{}) types.AsyncAssertion {
+func (g *Gomega) makeAsyncAssertion(asyncAssertionType AsyncAssertionType, offset int, actualOrCtx any, args ...any) types.AsyncAssertion {
 	baseOffset := 3
 	timeoutInterval := -time.Duration(1)
 	pollingInterval := -time.Duration(1)
-	intervals := []interface{}{}
+	intervals := []any{}
 	var ctx context.Context
 
 	actual := actualOrCtx
 	startingIndex := 0
 	if _, isCtx := actualOrCtx.(context.Context); isCtx && len(args) > 0 {
-		// the first argument is a context, we should accept it as the context _only if_ it is **not** the only argumnent **and** the second argument is not a parseable duration
+		// the first argument is a context, we should accept it as the context _only if_ it is **not** the only argument **and** the second argument is not a parseable duration
 		// this is due to an unfortunate ambiguity in early version of Gomega in which multi-type durations are allowed after the actual
 		if _, err := toDuration(args[0]); err != nil {
 			ctx = actualOrCtx.(context.Context)

e2e/vendor/github.com/onsi/gomega/internal/polling_signal_error.go

@@ -100,7 +100,7 @@ func (s *PollingSignalErrorImpl) TryAgainDuration() time.Duration {
 	return s.duration
 }
 
-func AsPollingSignalError(actual interface{}) (*PollingSignalErrorImpl, bool) {
+func AsPollingSignalError(actual any) (*PollingSignalErrorImpl, bool) {
 	if actual == nil {
 		return nil, false
 	}

e2e/vendor/github.com/onsi/gomega/internal/vetoptdesc.go

@@ -10,7 +10,7 @@ import (
 // Gomega matcher at the beginning it panics. This allows for rendering Gomega
 // matchers as part of an optional Description, as long as they're not in the
 // first slot.
-func vetOptionalDescription(assertion string, optionalDescription ...interface{}) {
+func vetOptionalDescription(assertion string, optionalDescription ...any) {
 	if len(optionalDescription) == 0 {
 		return
 	}

e2e/vendor/github.com/onsi/gomega/matchers.go

@@ -12,7 +12,7 @@ import (
 // Equal uses reflect.DeepEqual to compare actual with expected.  Equal is strict about
 // types when performing comparisons.
 // It is an error for both actual and expected to be nil.  Use BeNil() instead.
-func Equal(expected interface{}) types.GomegaMatcher {
+func Equal(expected any) types.GomegaMatcher {
 	return &matchers.EqualMatcher{
 		Expected: expected,
 	}
@@ -22,7 +22,7 @@ func Equal(expected interface{}) types.GomegaMatcher {
 // This is done by converting actual to have the type of expected before
 // attempting equality with reflect.DeepEqual.
 // It is an error for actual and expected to be nil.  Use BeNil() instead.
-func BeEquivalentTo(expected interface{}) types.GomegaMatcher {
+func BeEquivalentTo(expected any) types.GomegaMatcher {
 	return &matchers.BeEquivalentToMatcher{
 		Expected: expected,
 	}
@@ -31,7 +31,7 @@ func BeEquivalentTo(expected interface{}) types.GomegaMatcher {
 // BeComparableTo uses gocmp.Equal from github.com/google/go-cmp (instead of reflect.DeepEqual) to perform a deep comparison.
 // You can pass cmp.Option as options.
 // It is an error for actual and expected to be nil.  Use BeNil() instead.
-func BeComparableTo(expected interface{}, opts ...cmp.Option) types.GomegaMatcher {
+func BeComparableTo(expected any, opts ...cmp.Option) types.GomegaMatcher {
 	return &matchers.BeComparableToMatcher{
 		Expected: expected,
 		Options:  opts,
@@ -41,7 +41,7 @@ func BeComparableTo(expected interface{}, opts ...cmp.Option) types.GomegaMatche
 // BeIdenticalTo uses the == operator to compare actual with expected.
 // BeIdenticalTo is strict about types when performing comparisons.
 // It is an error for both actual and expected to be nil.  Use BeNil() instead.
-func BeIdenticalTo(expected interface{}) types.GomegaMatcher {
+func BeIdenticalTo(expected any) types.GomegaMatcher {
 	return &matchers.BeIdenticalToMatcher{
 		Expected: expected,
 	}
@@ -139,7 +139,7 @@ func Succeed() types.GomegaMatcher {
 // Error interface
 //
 // The optional second argument is a description of the error function, if used.  This is required when passing a function but is ignored in all other cases.
-func MatchError(expected interface{}, functionErrorDescription ...any) types.GomegaMatcher {
+func MatchError(expected any, functionErrorDescription ...any) types.GomegaMatcher {
 	return &matchers.MatchErrorMatcher{
 		Expected:           expected,
 		FuncErrDescription: functionErrorDescription,
@@ -202,11 +202,11 @@ func BeClosed() types.GomegaMatcher {
 //	Expect(myThing.IsValid()).Should(BeTrue())
 //
 // Finally, if you want to match the received object as well as get the actual received value into a variable, so you can reason further about the value received,
-// you can pass a pointer to a variable of the approriate type first, and second a matcher:
+// you can pass a pointer to a variable of the appropriate type first, and second a matcher:
 //
 //	var myThing thing
 //	Eventually(thingChan).Should(Receive(&myThing, ContainSubstring("bar")))
-func Receive(args ...interface{}) types.GomegaMatcher {
+func Receive(args ...any) types.GomegaMatcher {
 	return &matchers.ReceiveMatcher{
 		Args: args,
 	}
@@ -224,7 +224,7 @@ func Receive(args ...interface{}) types.GomegaMatcher {
 //
 // Of course, the value is actually sent to the channel.  The point of `BeSent` is less to make an assertion about the availability of the channel (which is typically an implementation detail that your test should not be concerned with).
 // Rather, the point of `BeSent` is to make it possible to easily and expressively write tests that can timeout on blocked channel sends.
-func BeSent(arg interface{}) types.GomegaMatcher {
+func BeSent(arg any) types.GomegaMatcher {
 	return &matchers.BeSentMatcher{
 		Arg: arg,
 	}
@@ -233,7 +233,7 @@ func BeSent(arg interface{}) types.GomegaMatcher {
 // MatchRegexp succeeds if actual is a string or stringer that matches the
 // passed-in regexp.  Optional arguments can be provided to construct a regexp
 // via fmt.Sprintf().
-func MatchRegexp(regexp string, args ...interface{}) types.GomegaMatcher {
+func MatchRegexp(regexp string, args ...any) types.GomegaMatcher {
 	return &matchers.MatchRegexpMatcher{
 		Regexp: regexp,
 		Args:   args,
@@ -243,7 +243,7 @@ func MatchRegexp(regexp string, args ...interface{}) types.GomegaMatcher {
 // ContainSubstring succeeds if actual is a string or stringer that contains the
 // passed-in substring.  Optional arguments can be provided to construct the substring
 // via fmt.Sprintf().
-func ContainSubstring(substr string, args ...interface{}) types.GomegaMatcher {
+func ContainSubstring(substr string, args ...any) types.GomegaMatcher {
 	return &matchers.ContainSubstringMatcher{
 		Substr: substr,
 		Args:   args,
@@ -253,7 +253,7 @@ func ContainSubstring(substr string, args ...interface{}) types.GomegaMatcher {
 // HavePrefix succeeds if actual is a string or stringer that contains the
 // passed-in string as a prefix.  Optional arguments can be provided to construct
 // via fmt.Sprintf().
-func HavePrefix(prefix string, args ...interface{}) types.GomegaMatcher {
+func HavePrefix(prefix string, args ...any) types.GomegaMatcher {
 	return &matchers.HavePrefixMatcher{
 		Prefix: prefix,
 		Args:   args,
@@ -263,7 +263,7 @@ func HavePrefix(prefix string, args ...interface{}) types.GomegaMatcher {
 // HaveSuffix succeeds if actual is a string or stringer that contains the
 // passed-in string as a suffix.  Optional arguments can be provided to construct
 // via fmt.Sprintf().
-func HaveSuffix(suffix string, args ...interface{}) types.GomegaMatcher {
+func HaveSuffix(suffix string, args ...any) types.GomegaMatcher {
 	return &matchers.HaveSuffixMatcher{
 		Suffix: suffix,
 		Args:   args,
@@ -273,7 +273,7 @@ func HaveSuffix(suffix string, args ...interface{}) types.GomegaMatcher {
 // MatchJSON succeeds if actual is a string or stringer of JSON that matches
 // the expected JSON.  The JSONs are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
-func MatchJSON(json interface{}) types.GomegaMatcher {
+func MatchJSON(json any) types.GomegaMatcher {
 	return &matchers.MatchJSONMatcher{
 		JSONToMatch: json,
 	}
@@ -282,7 +282,7 @@ func MatchJSON(json interface{}) types.GomegaMatcher {
 // MatchXML succeeds if actual is a string or stringer of XML that matches
 // the expected XML.  The XMLs are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like whitespaces shouldn't matter.
-func MatchXML(xml interface{}) types.GomegaMatcher {
+func MatchXML(xml any) types.GomegaMatcher {
 	return &matchers.MatchXMLMatcher{
 		XMLToMatch: xml,
 	}
@@ -291,7 +291,7 @@ func MatchXML(xml interface{}) types.GomegaMatcher {
 // MatchYAML succeeds if actual is a string or stringer of YAML that matches
 // the expected YAML.  The YAML's are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
-func MatchYAML(yaml interface{}) types.GomegaMatcher {
+func MatchYAML(yaml any) types.GomegaMatcher {
 	return &matchers.MatchYAMLMatcher{
 		YAMLToMatch: yaml,
 	}
@@ -338,7 +338,7 @@ func BeZero() types.GomegaMatcher {
 //
 //	var findings []string
 //	Expect([]string{"Foo", "FooBar"}).Should(ContainElement(ContainSubString("Bar", &findings)))
-func ContainElement(element interface{}, result ...interface{}) types.GomegaMatcher {
+func ContainElement(element any, result ...any) types.GomegaMatcher {
 	return &matchers.ContainElementMatcher{
 		Element: element,
 		Result:  result,
@@ -358,7 +358,7 @@ func ContainElement(element interface{}, result ...interface{}) types.GomegaMatc
 //	Expect(2).Should(BeElementOf(1, 2))
 //
 // Actual must be typed.
-func BeElementOf(elements ...interface{}) types.GomegaMatcher {
+func BeElementOf(elements ...any) types.GomegaMatcher {
 	return &matchers.BeElementOfMatcher{
 		Elements: elements,
 	}
@@ -368,7 +368,7 @@ func BeElementOf(elements ...interface{}) types.GomegaMatcher {
 // BeKeyOf() always uses Equal() to perform the match between actual and the map keys.
 //
 //	Expect("foo").Should(BeKeyOf(map[string]bool{"foo": true, "bar": false}))
-func BeKeyOf(element interface{}) types.GomegaMatcher {
+func BeKeyOf(element any) types.GomegaMatcher {
 	return &matchers.BeKeyOfMatcher{
 		Map: element,
 	}
@@ -388,14 +388,14 @@ func BeKeyOf(element interface{}) types.GomegaMatcher {
 //
 //	Expect([]string{"Foo", "FooBar"}).Should(ConsistOf([]string{"FooBar", "Foo"}))
 //
-// Note that Go's type system does not allow you to write this as ConsistOf([]string{"FooBar", "Foo"}...) as []string and []interface{} are different types - hence the need for this special rule.
+// Note that Go's type system does not allow you to write this as ConsistOf([]string{"FooBar", "Foo"}...) as []string and []any are different types - hence the need for this special rule.
-func ConsistOf(elements ...interface{}) types.GomegaMatcher {
+func ConsistOf(elements ...any) types.GomegaMatcher {
 	return &matchers.ConsistOfMatcher{
 		Elements: elements,
 	}
 }
 
-// HaveExactElements succeeds if actual contains elements that precisely match the elemets passed into the matcher. The ordering of the elements does matter.
+// HaveExactElements succeeds if actual contains elements that precisely match the elements passed into the matcher. The ordering of the elements does matter.
 // By default HaveExactElements() uses Equal() to match the elements, however custom matchers can be passed in instead.  Here are some examples:
 //
 //	Expect([]string{"Foo", "FooBar"}).Should(HaveExactElements("Foo", "FooBar"))
@@ -403,7 +403,7 @@ func ConsistOf(elements ...interface{}) types.GomegaMatcher {
 //	Expect([]string{"Foo", "FooBar"}).Should(HaveExactElements(ContainSubstring("Foo"), ContainSubstring("Foo")))
 //
 // Actual must be an array or slice.
-func HaveExactElements(elements ...interface{}) types.GomegaMatcher {
+func HaveExactElements(elements ...any) types.GomegaMatcher {
 	return &matchers.HaveExactElementsMatcher{
 		Elements: elements,
 	}
@@ -417,7 +417,7 @@ func HaveExactElements(elements ...interface{}) types.GomegaMatcher {
 //
 // Actual must be an array, slice or map.
 // For maps, ContainElements searches through the map's values.
-func ContainElements(elements ...interface{}) types.GomegaMatcher {
+func ContainElements(elements ...any) types.GomegaMatcher {
 	return &matchers.ContainElementsMatcher{
 		Elements: elements,
 	}
@@ -432,7 +432,7 @@ func ContainElements(elements ...interface{}) types.GomegaMatcher {
 //
 // Actual must be an array, slice or map.
 // For maps, HaveEach searches through the map's values.
-func HaveEach(element interface{}) types.GomegaMatcher {
+func HaveEach(element any) types.GomegaMatcher {
 	return &matchers.HaveEachMatcher{
 		Element: element,
 	}
@@ -443,7 +443,7 @@ func HaveEach(element interface{}) types.GomegaMatcher {
 // matcher can be passed in instead:
 //
 //	Expect(map[string]string{"Foo": "Bar", "BazFoo": "Duck"}).Should(HaveKey(MatchRegexp(`.+Foo$`)))
-func HaveKey(key interface{}) types.GomegaMatcher {
+func HaveKey(key any) types.GomegaMatcher {
 	return &matchers.HaveKeyMatcher{
 		Key: key,
 	}
@@ -455,7 +455,7 @@ func HaveKey(key interface{}) types.GomegaMatcher {
 //
 //	Expect(map[string]string{"Foo": "Bar", "BazFoo": "Duck"}).Should(HaveKeyWithValue("Foo", "Bar"))
 //	Expect(map[string]string{"Foo": "Bar", "BazFoo": "Duck"}).Should(HaveKeyWithValue(MatchRegexp(`.+Foo$`), "Bar"))
-func HaveKeyWithValue(key interface{}, value interface{}) types.GomegaMatcher {
+func HaveKeyWithValue(key any, value any) types.GomegaMatcher {
 	return &matchers.HaveKeyWithValueMatcher{
 		Key:   key,
 		Value: value,
@@ -483,7 +483,7 @@ func HaveKeyWithValue(key interface{}, value interface{}) types.GomegaMatcher {
 //	Expect(book).To(HaveField("Title", ContainSubstring("Les"))
 //	Expect(book).To(HaveField("Author.FirstName", Equal("Victor"))
 //	Expect(book).To(HaveField("Author.DOB.Year()", BeNumerically("<", 1900))
-func HaveField(field string, expected interface{}) types.GomegaMatcher {
+func HaveField(field string, expected any) types.GomegaMatcher {
 	return &matchers.HaveFieldMatcher{
 		Field:    field,
 		Expected: expected,
@@ -535,7 +535,7 @@ func HaveValue(matcher types.GomegaMatcher) types.GomegaMatcher {
 //	Expect(1.0).Should(BeNumerically(">=", 1.0))
 //	Expect(1.0).Should(BeNumerically("<", 3))
 //	Expect(1.0).Should(BeNumerically("<=", 1.0))
-func BeNumerically(comparator string, compareTo ...interface{}) types.GomegaMatcher {
+func BeNumerically(comparator string, compareTo ...any) types.GomegaMatcher {
 	return &matchers.BeNumericallyMatcher{
 		Comparator: comparator,
 		CompareTo:  compareTo,
@@ -562,7 +562,7 @@ func BeTemporally(comparator string, compareTo time.Time, threshold ...time.Dura
 //	Expect(5).Should(BeAssignableToTypeOf(-1))        // different values same type
 //	Expect("foo").Should(BeAssignableToTypeOf("bar")) // different values same type
 //	Expect(struct{ Foo string }{}).Should(BeAssignableToTypeOf(struct{ Foo string }{}))
-func BeAssignableToTypeOf(expected interface{}) types.GomegaMatcher {
+func BeAssignableToTypeOf(expected any) types.GomegaMatcher {
 	return &matchers.AssignableToTypeOfMatcher{
 		Expected: expected,
 	}
@@ -581,7 +581,7 @@ func Panic() types.GomegaMatcher {
 // matcher can be passed in instead:
 //
 //	Expect(fn).Should(PanicWith(MatchRegexp(`.+Foo$`)))
-func PanicWith(expected interface{}) types.GomegaMatcher {
+func PanicWith(expected any) types.GomegaMatcher {
 	return &matchers.PanicMatcher{Expected: expected}
 }
 
@@ -610,7 +610,7 @@ func BeADirectory() types.GomegaMatcher {
 //	Expect(resp).Should(HaveHTTPStatus(http.StatusOK))   // asserts that resp.StatusCode == 200
 //	Expect(resp).Should(HaveHTTPStatus("404 Not Found")) // asserts that resp.Status == "404 Not Found"
 //	Expect(resp).Should(HaveHTTPStatus(http.StatusOK, http.StatusNoContent))   // asserts that resp.StatusCode == 200 || resp.StatusCode == 204
-func HaveHTTPStatus(expected ...interface{}) types.GomegaMatcher {
+func HaveHTTPStatus(expected ...any) types.GomegaMatcher {
 	return &matchers.HaveHTTPStatusMatcher{Expected: expected}
 }
 
@@ -618,7 +618,7 @@ func HaveHTTPStatus(expected ...interface{}) types.GomegaMatcher {
 // Actual must be either a *http.Response or *httptest.ResponseRecorder.
 // Expected must be a string header name, followed by a header value which
 // can be a string, or another matcher.
-func HaveHTTPHeaderWithValue(header string, value interface{}) types.GomegaMatcher {
+func HaveHTTPHeaderWithValue(header string, value any) types.GomegaMatcher {
 	return &matchers.HaveHTTPHeaderWithValueMatcher{
 		Header: header,
 		Value:  value,
@@ -628,7 +628,7 @@ func HaveHTTPHeaderWithValue(header string, value interface{}) types.GomegaMatch
 // HaveHTTPBody matches if the body matches.
 // Actual must be either a *http.Response or *httptest.ResponseRecorder.
 // Expected must be either a string, []byte, or other matcher
-func HaveHTTPBody(expected interface{}) types.GomegaMatcher {
+func HaveHTTPBody(expected any) types.GomegaMatcher {
 	return &matchers.HaveHTTPBodyMatcher{Expected: expected}
 }
 
@@ -687,15 +687,15 @@ func Not(matcher types.GomegaMatcher) types.GomegaMatcher {
 //	 Expect(1).To(WithTransform(failingplus1, Equal(2)))
 //
 // And(), Or(), Not() and WithTransform() allow matchers to be composed into complex expressions.
-func WithTransform(transform interface{}, matcher types.GomegaMatcher) types.GomegaMatcher {
+func WithTransform(transform any, matcher types.GomegaMatcher) types.GomegaMatcher {
 	return matchers.NewWithTransformMatcher(transform, matcher)
 }
 
 // Satisfy matches the actual value against the `predicate` function.
-// The given predicate must be a function of one paramter that returns bool.
+// The given predicate must be a function of one parameter that returns bool.
 //
 //	var isEven = func(i int) bool { return i%2 == 0 }
 //	Expect(2).To(Satisfy(isEven))
-func Satisfy(predicate interface{}) types.GomegaMatcher {
+func Satisfy(predicate any) types.GomegaMatcher {
 	return matchers.NewSatisfyMatcher(predicate)
 }

e2e/vendor/github.com/onsi/gomega/matchers/and.go

@@ -14,7 +14,7 @@ type AndMatcher struct {
 	firstFailedMatcher types.GomegaMatcher
 }
 
-func (m *AndMatcher) Match(actual interface{}) (success bool, err error) {
+func (m *AndMatcher) Match(actual any) (success bool, err error) {
 	m.firstFailedMatcher = nil
 	for _, matcher := range m.Matchers {
 		success, err := matcher.Match(actual)
@@ -26,16 +26,16 @@ func (m *AndMatcher) Match(actual interface{}) (success bool, err error) {
 	return true, nil
 }
 
-func (m *AndMatcher) FailureMessage(actual interface{}) (message string) {
+func (m *AndMatcher) FailureMessage(actual any) (message string) {
 	return m.firstFailedMatcher.FailureMessage(actual)
 }
 
-func (m *AndMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (m *AndMatcher) NegatedFailureMessage(actual any) (message string) {
 	// not the most beautiful list of matchers, but not bad either...
 	return format.Message(actual, fmt.Sprintf("To not satisfy all of these matchers: %s", m.Matchers))
 }
 
-func (m *AndMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+func (m *AndMatcher) MatchMayChangeInTheFuture(actual any) bool {
 	/*
 		Example with 3 matchers: A, B, C
 

e2e/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go

@@ -10,10 +10,10 @@ import (
 )
 
 type AssignableToTypeOfMatcher struct {
-	Expected interface{}
+	Expected any
 }
 
-func (matcher *AssignableToTypeOfMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *AssignableToTypeOfMatcher) Match(actual any) (success bool, err error) {
 	if actual == nil && matcher.Expected == nil {
 		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
 	} else if matcher.Expected == nil {
@@ -28,10 +28,10 @@ func (matcher *AssignableToTypeOfMatcher) Match(actual interface{}) (success boo
 	return actualType.AssignableTo(expectedType), nil
 }
 
-func (matcher *AssignableToTypeOfMatcher) FailureMessage(actual interface{}) string {
+func (matcher *AssignableToTypeOfMatcher) FailureMessage(actual any) string {
 	return format.Message(actual, fmt.Sprintf("to be assignable to the type: %T", matcher.Expected))
 }
 
-func (matcher *AssignableToTypeOfMatcher) NegatedFailureMessage(actual interface{}) string {
+func (matcher *AssignableToTypeOfMatcher) NegatedFailureMessage(actual any) string {
 	return format.Message(actual, fmt.Sprintf("not to be assignable to the type: %T", matcher.Expected))
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_a_directory.go

@@ -24,11 +24,11 @@ func (t notADirectoryError) Error() string {
 }
 
 type BeADirectoryMatcher struct {
-	expected interface{}
+	expected any
 	err      error
 }
 
-func (matcher *BeADirectoryMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeADirectoryMatcher) Match(actual any) (success bool, err error) {
 	actualFilename, ok := actual.(string)
 	if !ok {
 		return false, fmt.Errorf("BeADirectoryMatcher matcher expects a file path")
@@ -47,10 +47,10 @@ func (matcher *BeADirectoryMatcher) Match(actual interface{}) (success bool, err
 	return true, nil
 }
 
-func (matcher *BeADirectoryMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeADirectoryMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, fmt.Sprintf("to be a directory: %s", matcher.err))
 }
 
-func (matcher *BeADirectoryMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeADirectoryMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not be a directory")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go

@@ -24,11 +24,11 @@ func (t notARegularFileError) Error() string {
 }
 
 type BeARegularFileMatcher struct {
-	expected interface{}
+	expected any
 	err      error
 }
 
-func (matcher *BeARegularFileMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeARegularFileMatcher) Match(actual any) (success bool, err error) {
 	actualFilename, ok := actual.(string)
 	if !ok {
 		return false, fmt.Errorf("BeARegularFileMatcher matcher expects a file path")
@@ -47,10 +47,10 @@ func (matcher *BeARegularFileMatcher) Match(actual interface{}) (success bool, e
 	return true, nil
 }
 
-func (matcher *BeARegularFileMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeARegularFileMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, fmt.Sprintf("to be a regular file: %s", matcher.err))
 }
 
-func (matcher *BeARegularFileMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeARegularFileMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not be a regular file")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go

@@ -10,10 +10,10 @@ import (
 )
 
 type BeAnExistingFileMatcher struct {
-	expected interface{}
+	expected any
 }
 
-func (matcher *BeAnExistingFileMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeAnExistingFileMatcher) Match(actual any) (success bool, err error) {
 	actualFilename, ok := actual.(string)
 	if !ok {
 		return false, fmt.Errorf("BeAnExistingFileMatcher matcher expects a file path")
@@ -31,10 +31,10 @@ func (matcher *BeAnExistingFileMatcher) Match(actual interface{}) (success bool,
 	return true, nil
 }
 
-func (matcher *BeAnExistingFileMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeAnExistingFileMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to exist")
 }
 
-func (matcher *BeAnExistingFileMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeAnExistingFileMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to exist")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go

@@ -12,7 +12,7 @@ import (
 type BeClosedMatcher struct {
 }
 
-func (matcher *BeClosedMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeClosedMatcher) Match(actual any) (success bool, err error) {
 	if !isChan(actual) {
 		return false, fmt.Errorf("BeClosed matcher expects a channel.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -39,10 +39,10 @@ func (matcher *BeClosedMatcher) Match(actual interface{}) (success bool, err err
 	return closed, nil
 }
 
-func (matcher *BeClosedMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeClosedMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be closed")
 }
 
-func (matcher *BeClosedMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeClosedMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be open")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go

@@ -9,11 +9,11 @@ import (
 )
 
 type BeComparableToMatcher struct {
-	Expected interface{}
+	Expected any
 	Options  cmp.Options
 }
 
-func (matcher *BeComparableToMatcher) Match(actual interface{}) (success bool, matchErr error) {
+func (matcher *BeComparableToMatcher) Match(actual any) (success bool, matchErr error) {
 	if actual == nil && matcher.Expected == nil {
 		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
 	}
@@ -40,10 +40,10 @@ func (matcher *BeComparableToMatcher) Match(actual interface{}) (success bool, m
 	return cmp.Equal(actual, matcher.Expected, matcher.Options...), nil
 }
 
-func (matcher *BeComparableToMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeComparableToMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprint("Expected object to be comparable, diff: ", cmp.Diff(actual, matcher.Expected, matcher.Options...))
 }
 
-func (matcher *BeComparableToMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeComparableToMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be comparable to", matcher.Expected)
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_element_of_matcher.go

@@ -10,10 +10,10 @@ import (
 )
 
 type BeElementOfMatcher struct {
-	Elements []interface{}
+	Elements []any
 }
 
-func (matcher *BeElementOfMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeElementOfMatcher) Match(actual any) (success bool, err error) {
 	if reflect.TypeOf(actual) == nil {
 		return false, fmt.Errorf("BeElement matcher expects actual to be typed")
 	}
@@ -34,10 +34,10 @@ func (matcher *BeElementOfMatcher) Match(actual interface{}) (success bool, err
 	return false, lastError
 }
 
-func (matcher *BeElementOfMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeElementOfMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be an element of", presentable(matcher.Elements))
 }
 
-func (matcher *BeElementOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeElementOfMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be an element of", presentable(matcher.Elements))
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go

@@ -13,7 +13,7 @@ import (
 type BeEmptyMatcher struct {
 }
 
-func (matcher *BeEmptyMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeEmptyMatcher) Match(actual any) (success bool, err error) {
 	// short-circuit the iterator case, as we only need to see the first
 	// element, if any.
 	if miter.IsIter(actual) {
@@ -34,10 +34,10 @@ func (matcher *BeEmptyMatcher) Match(actual interface{}) (success bool, err erro
 	return length == 0, nil
 }
 
-func (matcher *BeEmptyMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeEmptyMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be empty")
 }
 
-func (matcher *BeEmptyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeEmptyMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be empty")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go

@@ -10,10 +10,10 @@ import (
 )
 
 type BeEquivalentToMatcher struct {
-	Expected interface{}
+	Expected any
 }
 
-func (matcher *BeEquivalentToMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeEquivalentToMatcher) Match(actual any) (success bool, err error) {
 	if actual == nil && matcher.Expected == nil {
 		return false, fmt.Errorf("Both actual and expected must not be nil.")
 	}
@@ -27,10 +27,10 @@ func (matcher *BeEquivalentToMatcher) Match(actual interface{}) (success bool, e
 	return reflect.DeepEqual(convertedActual, matcher.Expected), nil
 }
 
-func (matcher *BeEquivalentToMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeEquivalentToMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be equivalent to", matcher.Expected)
 }
 
-func (matcher *BeEquivalentToMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeEquivalentToMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be equivalent to", matcher.Expected)
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_false_matcher.go

@@ -12,7 +12,7 @@ type BeFalseMatcher struct {
 	Reason string
 }
 
-func (matcher *BeFalseMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeFalseMatcher) Match(actual any) (success bool, err error) {
 	if !isBool(actual) {
 		return false, fmt.Errorf("Expected a boolean.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -20,7 +20,7 @@ func (matcher *BeFalseMatcher) Match(actual interface{}) (success bool, err erro
 	return actual == false, nil
 }
 
-func (matcher *BeFalseMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeFalseMatcher) FailureMessage(actual any) (message string) {
 	if matcher.Reason == "" {
 		return format.Message(actual, "to be false")
 	} else {
@@ -28,7 +28,7 @@ func (matcher *BeFalseMatcher) FailureMessage(actual interface{}) (message strin
 	}
 }
 
-func (matcher *BeFalseMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeFalseMatcher) NegatedFailureMessage(actual any) (message string) {
 	if matcher.Reason == "" {
 		return format.Message(actual, "not to be false")
 	} else {

e2e/vendor/github.com/onsi/gomega/matchers/be_identical_to.go

@@ -10,10 +10,10 @@ import (
 )
 
 type BeIdenticalToMatcher struct {
-	Expected interface{}
+	Expected any
 }
 
-func (matcher *BeIdenticalToMatcher) Match(actual interface{}) (success bool, matchErr error) {
+func (matcher *BeIdenticalToMatcher) Match(actual any) (success bool, matchErr error) {
 	if actual == nil && matcher.Expected == nil {
 		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
 	}
@@ -30,10 +30,10 @@ func (matcher *BeIdenticalToMatcher) Match(actual interface{}) (success bool, ma
 	return actual == matcher.Expected, nil
 }
 
-func (matcher *BeIdenticalToMatcher) FailureMessage(actual interface{}) string {
+func (matcher *BeIdenticalToMatcher) FailureMessage(actual any) string {
 	return format.Message(actual, "to be identical to", matcher.Expected)
 }
 
-func (matcher *BeIdenticalToMatcher) NegatedFailureMessage(actual interface{}) string {
+func (matcher *BeIdenticalToMatcher) NegatedFailureMessage(actual any) string {
 	return format.Message(actual, "not to be identical to", matcher.Expected)
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_key_of_matcher.go

@@ -8,10 +8,10 @@ import (
 )
 
 type BeKeyOfMatcher struct {
-	Map interface{}
+	Map any
 }
 
-func (matcher *BeKeyOfMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeKeyOfMatcher) Match(actual any) (success bool, err error) {
 	if !isMap(matcher.Map) {
 		return false, fmt.Errorf("BeKeyOf matcher needs expected to be a map type")
 	}
@@ -36,10 +36,10 @@ func (matcher *BeKeyOfMatcher) Match(actual interface{}) (success bool, err erro
 	return false, lastError
 }
 
-func (matcher *BeKeyOfMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeKeyOfMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be a key of", presentable(valuesOf(matcher.Map)))
 }
 
-func (matcher *BeKeyOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeKeyOfMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be a key of", presentable(valuesOf(matcher.Map)))
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go

@@ -7,14 +7,14 @@ import "github.com/onsi/gomega/format"
 type BeNilMatcher struct {
 }
 
-func (matcher *BeNilMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeNilMatcher) Match(actual any) (success bool, err error) {
 	return isNil(actual), nil
 }
 
-func (matcher *BeNilMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeNilMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be nil")
 }
 
-func (matcher *BeNilMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeNilMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be nil")
 }

e2e/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go

@@ -11,18 +11,18 @@ import (
 
 type BeNumericallyMatcher struct {
 	Comparator string
-	CompareTo  []interface{}
+	CompareTo  []any
 }
 
-func (matcher *BeNumericallyMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeNumericallyMatcher) FailureMessage(actual any) (message string) {
 	return matcher.FormatFailureMessage(actual, false)
 }
 
-func (matcher *BeNumericallyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeNumericallyMatcher) NegatedFailureMessage(actual any) (message string) {
 	return matcher.FormatFailureMessage(actual, true)
 }
 
-func (matcher *BeNumericallyMatcher) FormatFailureMessage(actual interface{}, negated bool) (message string) {
+func (matcher *BeNumericallyMatcher) FormatFailureMessage(actual any, negated bool) (message string) {
 	if len(matcher.CompareTo) == 1 {
 		message = fmt.Sprintf("to be %s", matcher.Comparator)
 	} else {
@@ -34,7 +34,7 @@ func (matcher *BeNumericallyMatcher) FormatFailureMessage(actual interface{}, ne
 	return format.Message(actual, message, matcher.CompareTo[0])
 }
 
-func (matcher *BeNumericallyMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error) {
 	if len(matcher.CompareTo) == 0 || len(matcher.CompareTo) > 2 {
 		return false, fmt.Errorf("BeNumerically requires 1 or 2 CompareTo arguments.  Got:\n%s", format.Object(matcher.CompareTo, 1))
 	}

e2e/vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go

@@ -10,11 +10,11 @@ import (
 )
 
 type BeSentMatcher struct {
-	Arg           interface{}
+	Arg           any
 	channelClosed bool
 }
 
-func (matcher *BeSentMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeSentMatcher) Match(actual any) (success bool, err error) {
 	if !isChan(actual) {
 		return false, fmt.Errorf("BeSent expects a channel.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -56,15 +56,15 @@ func (matcher *BeSentMatcher) Match(actual interface{}) (success bool, err error
 	return didSend, nil
 }
 
-func (matcher *BeSentMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeSentMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to send:", matcher.Arg)
 }
 
-func (matcher *BeSentMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeSentMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to send:", matcher.Arg)
 }
 
-func (matcher *BeSentMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+func (matcher *BeSentMatcher) MatchMayChangeInTheFuture(actual any) bool {
 	if !isChan(actual) {
 		return false
 	}

e2e/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go

@@ -15,17 +15,17 @@ type BeTemporallyMatcher struct {
 	Threshold  []time.Duration
 }
 
-func (matcher *BeTemporallyMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeTemporallyMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, fmt.Sprintf("to be %s", matcher.Comparator), matcher.CompareTo)
 }
 
-func (matcher *BeTemporallyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeTemporallyMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, fmt.Sprintf("not to be %s", matcher.Comparator), matcher.CompareTo)
 }
 
-func (matcher *BeTemporallyMatcher) Match(actual interface{}) (bool, error) {
+func (matcher *BeTemporallyMatcher) Match(actual any) (bool, error) {
 	// predicate to test for time.Time type
-	isTime := func(t interface{}) bool {
+	isTime := func(t any) bool {
 		_, ok := t.(time.Time)
 		return ok
 	}

e2e/vendor/github.com/onsi/gomega/matchers/be_true_matcher.go

@@ -12,7 +12,7 @@ type BeTrueMatcher struct {
 	Reason string
 }
 
-func (matcher *BeTrueMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeTrueMatcher) Match(actual any) (success bool, err error) {
 	if !isBool(actual) {
 		return false, fmt.Errorf("Expected a boolean.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -20,7 +20,7 @@ func (matcher *BeTrueMatcher) Match(actual interface{}) (success bool, err error
 	return actual.(bool), nil
 }
 
-func (matcher *BeTrueMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeTrueMatcher) FailureMessage(actual any) (message string) {
 	if matcher.Reason == "" {
 		return format.Message(actual, "to be true")
 	} else {
@@ -28,7 +28,7 @@ func (matcher *BeTrueMatcher) FailureMessage(actual interface{}) (message string
 	}
 }
 
-func (matcher *BeTrueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeTrueMatcher) NegatedFailureMessage(actual any) (message string) {
 	if matcher.Reason == "" {
 		return format.Message(actual, "not to be true")
 	} else {

e2e/vendor/github.com/onsi/gomega/matchers/be_zero_matcher.go

@@ -9,7 +9,7 @@ import (
 type BeZeroMatcher struct {
 }
 
-func (matcher *BeZeroMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *BeZeroMatcher) Match(actual any) (success bool, err error) {
 	if actual == nil {
 		return true, nil
 	}
@@ -19,10 +19,10 @@ func (matcher *BeZeroMatcher) Match(actual interface{}) (success bool, err error
 
 }
 
-func (matcher *BeZeroMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *BeZeroMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to be zero-valued")
 }
 
-func (matcher *BeZeroMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *BeZeroMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to be zero-valued")
 }

e2e/vendor/github.com/onsi/gomega/matchers/consist_of.go

@@ -12,12 +12,12 @@ import (
 )
 
 type ConsistOfMatcher struct {
-	Elements        []interface{}
+	Elements        []any
-	missingElements []interface{}
+	missingElements []any
-	extraElements   []interface{}
+	extraElements   []any
 }
 
-func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *ConsistOfMatcher) Match(actual any) (success bool, err error) {
 	if !isArrayOrSlice(actual) && !isMap(actual) && !miter.IsIter(actual) {
 		return false, fmt.Errorf("ConsistOf matcher expects an array/slice/map/iter.Seq/iter.Seq2.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -35,19 +35,19 @@ func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err er
 		return true, nil
 	}
 
-	var missingMatchers []interface{}
+	var missingMatchers []any
 	matcher.extraElements, missingMatchers = bipartiteGraph.FreeLeftRight(edges)
 	matcher.missingElements = equalMatchersToElements(missingMatchers)
 
 	return false, nil
 }
 
-func neighbours(value, matcher interface{}) (bool, error) {
+func neighbours(value, matcher any) (bool, error) {
 	match, err := matcher.(omegaMatcher).Match(value)
 	return match && err == nil, nil
 }
 
-func equalMatchersToElements(matchers []interface{}) (elements []interface{}) {
+func equalMatchersToElements(matchers []any) (elements []any) {
 	for _, matcher := range matchers {
 		if equalMatcher, ok := matcher.(*EqualMatcher); ok {
 			elements = append(elements, equalMatcher.Expected)
@@ -60,7 +60,7 @@ func equalMatchersToElements(matchers []interface{}) (elements []interface{}) {
 	return
 }
 
-func flatten(elems []interface{}) []interface{} {
+func flatten(elems []any) []any {
 	if len(elems) != 1 ||
 		!(isArrayOrSlice(elems[0]) ||
 			(miter.IsIter(elems[0]) && !miter.IsSeq2(elems[0]))) {
@@ -77,14 +77,14 @@ func flatten(elems []interface{}) []interface{} {
 	}
 
 	value := reflect.ValueOf(elems[0])
-	flattened := make([]interface{}, value.Len())
+	flattened := make([]any, value.Len())
 	for i := 0; i < value.Len(); i++ {
 		flattened[i] = value.Index(i).Interface()
 	}
 	return flattened
 }
 
-func matchers(expectedElems []interface{}) (matchers []interface{}) {
+func matchers(expectedElems []any) (matchers []any) {
 	for _, e := range flatten(expectedElems) {
 		if e == nil {
 			matchers = append(matchers, &BeNilMatcher{})
@@ -97,11 +97,11 @@ func matchers(expectedElems []interface{}) (matchers []interface{}) {
 	return
 }
 
-func presentable(elems []interface{}) interface{} {
+func presentable(elems []any) any {
 	elems = flatten(elems)
 
 	if len(elems) == 0 {
-		return []interface{}{}
+		return []any{}
 	}
 
 	sv := reflect.ValueOf(elems)
@@ -125,9 +125,9 @@ func presentable(elems []interface{}) interface{} {
 	return ss.Interface()
 }
 
-func valuesOf(actual interface{}) []interface{} {
+func valuesOf(actual any) []any {
 	value := reflect.ValueOf(actual)
-	values := []interface{}{}
+	values := []any{}
 	if miter.IsIter(actual) {
 		if miter.IsSeq2(actual) {
 			miter.IterateKV(actual, func(k, v reflect.Value) bool {
@@ -154,7 +154,7 @@ func valuesOf(actual interface{}) []interface{} {
 	return values
 }
 
-func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *ConsistOfMatcher) FailureMessage(actual any) (message string) {
 	message = format.Message(actual, "to consist of", presentable(matcher.Elements))
 	message = appendMissingElements(message, matcher.missingElements)
 	if len(matcher.extraElements) > 0 {
@@ -164,7 +164,7 @@ func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message str
 	return
 }
 
-func appendMissingElements(message string, missingElements []interface{}) string {
+func appendMissingElements(message string, missingElements []any) string {
 	if len(missingElements) == 0 {
 		return message
 	}
@@ -172,6 +172,6 @@ func appendMissingElements(message string, missingElements []interface{}) string
 		format.Object(presentable(missingElements), 1))
 }
 
-func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to consist of", presentable(matcher.Elements))
 }

e2e/vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go

@@ -12,11 +12,11 @@ import (
 )
 
 type ContainElementMatcher struct {
-	Element interface{}
+	Element any
-	Result  []interface{}
+	Result  []any
 }
 
-func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *ContainElementMatcher) Match(actual any) (success bool, err error) {
 	if !isArrayOrSlice(actual) && !isMap(actual) && !miter.IsIter(actual) {
 		return false, fmt.Errorf("ContainElement matcher expects an array/slice/map/iterator.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -132,14 +132,14 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	var lastError error
 
 	if !miter.IsIter(actual) {
-		var valueAt func(int) interface{}
+		var valueAt func(int) any
 		var foundAt func(int)
 		// We're dealing with an array/slice/map, so in all cases we can iterate
 		// over the elements in actual using indices (that can be considered
 		// keys in case of maps).
 		if isMap(actual) {
 			keys := value.MapKeys()
-			valueAt = func(i int) interface{} {
+			valueAt = func(i int) any {
 				return value.MapIndex(keys[i]).Interface()
 			}
 			if result.Kind() != reflect.Invalid {
@@ -150,7 +150,7 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 				}
 			}
 		} else {
-			valueAt = func(i int) interface{} {
+			valueAt = func(i int) any {
 				return value.Index(i).Interface()
 			}
 			if result.Kind() != reflect.Invalid {
@@ -251,7 +251,7 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	}
 
 	// pick up any findings the test is interested in as it specified a non-nil
-	// result reference. However, the expection always is that there are at
+	// result reference. However, the expectation always is that there are at
 	// least one or multiple findings. So, if a result is expected, but we had
 	// no findings, then this is an error.
 	findings := getFindings()
@@ -284,10 +284,10 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	return true, nil
 }
 
-func (matcher *ContainElementMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *ContainElementMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to contain element matching", matcher.Element)
 }
 
-func (matcher *ContainElementMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *ContainElementMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to contain element matching", matcher.Element)
 }

e2e/vendor/github.com/onsi/gomega/matchers/contain_elements_matcher.go

@@ -9,11 +9,11 @@ import (
 )
 
 type ContainElementsMatcher struct {
-	Elements        []interface{}
+	Elements        []any
-	missingElements []interface{}
+	missingElements []any
 }
 
-func (matcher *ContainElementsMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *ContainElementsMatcher) Match(actual any) (success bool, err error) {
 	if !isArrayOrSlice(actual) && !isMap(actual) && !miter.IsIter(actual) {
 		return false, fmt.Errorf("ContainElements matcher expects an array/slice/map/iter.Seq/iter.Seq2.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -35,11 +35,11 @@ func (matcher *ContainElementsMatcher) Match(actual interface{}) (success bool,
 	return false, nil
 }
 
-func (matcher *ContainElementsMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *ContainElementsMatcher) FailureMessage(actual any) (message string) {
 	message = format.Message(actual, "to contain elements", presentable(matcher.Elements))
 	return appendMissingElements(message, matcher.missingElements)
 }
 
-func (matcher *ContainElementsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *ContainElementsMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to contain elements", presentable(matcher.Elements))
 }

e2e/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go

@@ -11,10 +11,10 @@ import (
 
 type ContainSubstringMatcher struct {
 	Substr string
-	Args   []interface{}
+	Args   []any
 }
 
-func (matcher *ContainSubstringMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *ContainSubstringMatcher) Match(actual any) (success bool, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return false, fmt.Errorf("ContainSubstring matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
@@ -31,10 +31,10 @@ func (matcher *ContainSubstringMatcher) stringToMatch() string {
 	return stringToMatch
 }
 
-func (matcher *ContainSubstringMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *ContainSubstringMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to contain substring", matcher.stringToMatch())
 }
 
-func (matcher *ContainSubstringMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *ContainSubstringMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to contain substring", matcher.stringToMatch())
 }

e2e/vendor/github.com/onsi/gomega/matchers/equal_matcher.go

@@ -9,10 +9,10 @@ import (
 )
 
 type EqualMatcher struct {
-	Expected interface{}
+	Expected any
 }
 
-func (matcher *EqualMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *EqualMatcher) Match(actual any) (success bool, err error) {
 	if actual == nil && matcher.Expected == nil {
 		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
 	}
@@ -27,7 +27,7 @@ func (matcher *EqualMatcher) Match(actual interface{}) (success bool, err error)
 	return reflect.DeepEqual(actual, matcher.Expected), nil
 }
 
-func (matcher *EqualMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *EqualMatcher) FailureMessage(actual any) (message string) {
 	actualString, actualOK := actual.(string)
 	expectedString, expectedOK := matcher.Expected.(string)
 	if actualOK && expectedOK {
@@ -37,6 +37,6 @@ func (matcher *EqualMatcher) FailureMessage(actual interface{}) (message string)
 	return format.Message(actual, "to equal", matcher.Expected)
 }
 
-func (matcher *EqualMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *EqualMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to equal", matcher.Expected)
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go

@@ -12,7 +12,7 @@ type HaveCapMatcher struct {
 	Count int
 }
 
-func (matcher *HaveCapMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveCapMatcher) Match(actual any) (success bool, err error) {
 	length, ok := capOf(actual)
 	if !ok {
 		return false, fmt.Errorf("HaveCap matcher expects a array/channel/slice.  Got:\n%s", format.Object(actual, 1))
@@ -21,10 +21,10 @@ func (matcher *HaveCapMatcher) Match(actual interface{}) (success bool, err erro
 	return length == matcher.Count, nil
 }
 
-func (matcher *HaveCapMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveCapMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nto have capacity %d", format.Object(actual, 1), matcher.Count)
 }
 
-func (matcher *HaveCapMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveCapMatcher) NegatedFailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nnot to have capacity %d", format.Object(actual, 1), matcher.Count)
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_each_matcher.go

@@ -9,10 +9,10 @@ import (
 )
 
 type HaveEachMatcher struct {
-	Element interface{}
+	Element any
 }
 
-func (matcher *HaveEachMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveEachMatcher) Match(actual any) (success bool, err error) {
 	if !isArrayOrSlice(actual) && !isMap(actual) && !miter.IsIter(actual) {
 		return false, fmt.Errorf("HaveEach matcher expects an array/slice/map/iter.Seq/iter.Seq2.  Got:\n%s",
 			format.Object(actual, 1))
@@ -61,14 +61,14 @@ func (matcher *HaveEachMatcher) Match(actual interface{}) (success bool, err err
 			format.Object(actual, 1))
 	}
 
-	var valueAt func(int) interface{}
+	var valueAt func(int) any
 	if isMap(actual) {
 		keys := value.MapKeys()
-		valueAt = func(i int) interface{} {
+		valueAt = func(i int) any {
 			return value.MapIndex(keys[i]).Interface()
 		}
 	} else {
-		valueAt = func(i int) interface{} {
+		valueAt = func(i int) any {
 			return value.Index(i).Interface()
 		}
 	}
@@ -89,11 +89,11 @@ func (matcher *HaveEachMatcher) Match(actual interface{}) (success bool, err err
 }
 
 // FailureMessage returns a suitable failure message.
-func (matcher *HaveEachMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveEachMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to contain element matching", matcher.Element)
 }
 
 // NegatedFailureMessage returns a suitable negated failure message.
-func (matcher *HaveEachMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveEachMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to contain element matching", matcher.Element)
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go

@@ -14,13 +14,13 @@ type mismatchFailure struct {
 }
 
 type HaveExactElementsMatcher struct {
-	Elements         []interface{}
+	Elements         []any
 	mismatchFailures []mismatchFailure
 	missingIndex     int
 	extraIndex       int
 }
 
-func (matcher *HaveExactElementsMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err error) {
 	matcher.resetState()
 
 	if isMap(actual) || miter.IsSeq2(actual) {
@@ -108,7 +108,7 @@ func (matcher *HaveExactElementsMatcher) Match(actual interface{}) (success bool
 	return success, nil
 }
 
-func (matcher *HaveExactElementsMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveExactElementsMatcher) FailureMessage(actual any) (message string) {
 	message = format.Message(actual, "to have exact elements with", presentable(matcher.Elements))
 	if matcher.missingIndex > 0 {
 		message = fmt.Sprintf("%s\nthe missing elements start from index %d", message, matcher.missingIndex)
@@ -125,7 +125,7 @@ func (matcher *HaveExactElementsMatcher) FailureMessage(actual interface{}) (mes
 	return
 }
 
-func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to contain elements", presentable(matcher.Elements))
 }
 

e2e/vendor/github.com/onsi/gomega/matchers/have_existing_field_matcher.go

@@ -11,7 +11,7 @@ type HaveExistingFieldMatcher struct {
 	Field string
 }
 
-func (matcher *HaveExistingFieldMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveExistingFieldMatcher) Match(actual any) (success bool, err error) {
 	// we don't care about the field's actual value, just about any error in
 	// trying to find the field (or method).
 	_, err = extractField(actual, matcher.Field, "HaveExistingField")
@@ -27,10 +27,10 @@ func (matcher *HaveExistingFieldMatcher) Match(actual interface{}) (success bool
 	return false, err
 }
 
-func (matcher *HaveExistingFieldMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveExistingFieldMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nto have field '%s'", format.Object(actual, 1), matcher.Field)
 }
 
-func (matcher *HaveExistingFieldMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveExistingFieldMatcher) NegatedFailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nnot to have field '%s'", format.Object(actual, 1), matcher.Field)
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_field.go

@@ -17,7 +17,7 @@ func (e missingFieldError) Error() string {
 	return string(e)
 }
 
-func extractField(actual interface{}, field string, matchername string) (any, error) {
+func extractField(actual any, field string, matchername string) (any, error) {
 	fields := strings.SplitN(field, ".", 2)
 	actualValue := reflect.ValueOf(actual)
 
@@ -68,7 +68,7 @@ func extractField(actual interface{}, field string, matchername string) (any, er
 
 type HaveFieldMatcher struct {
 	Field    string
-	Expected interface{}
+	Expected any
 }
 
 func (matcher *HaveFieldMatcher) expectedMatcher() omegaMatcher {
@@ -80,7 +80,7 @@ func (matcher *HaveFieldMatcher) expectedMatcher() omegaMatcher {
 	return expectedMatcher
 }
 
-func (matcher *HaveFieldMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveFieldMatcher) Match(actual any) (success bool, err error) {
 	extractedField, err := extractField(actual, matcher.Field, "HaveField")
 	if err != nil {
 		return false, err
@@ -89,7 +89,7 @@ func (matcher *HaveFieldMatcher) Match(actual interface{}) (success bool, err er
 	return matcher.expectedMatcher().Match(extractedField)
 }
 
-func (matcher *HaveFieldMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveFieldMatcher) FailureMessage(actual any) (message string) {
 	extractedField, err := extractField(actual, matcher.Field, "HaveField")
 	if err != nil {
 		// this really shouldn't happen
@@ -101,7 +101,7 @@ func (matcher *HaveFieldMatcher) FailureMessage(actual interface{}) (message str
 	return message
 }
 
-func (matcher *HaveFieldMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveFieldMatcher) NegatedFailureMessage(actual any) (message string) {
 	extractedField, err := extractField(actual, matcher.Field, "HaveField")
 	if err != nil {
 		// this really shouldn't happen

e2e/vendor/github.com/onsi/gomega/matchers/have_http_body_matcher.go

@@ -11,12 +11,12 @@ import (
 )
 
 type HaveHTTPBodyMatcher struct {
-	Expected       interface{}
+	Expected       any
-	cachedResponse interface{}
+	cachedResponse any
 	cachedBody     []byte
 }
 
-func (matcher *HaveHTTPBodyMatcher) Match(actual interface{}) (bool, error) {
+func (matcher *HaveHTTPBodyMatcher) Match(actual any) (bool, error) {
 	body, err := matcher.body(actual)
 	if err != nil {
 		return false, err
@@ -34,7 +34,7 @@ func (matcher *HaveHTTPBodyMatcher) Match(actual interface{}) (bool, error) {
 	}
 }
 
-func (matcher *HaveHTTPBodyMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveHTTPBodyMatcher) FailureMessage(actual any) (message string) {
 	body, err := matcher.body(actual)
 	if err != nil {
 		return fmt.Sprintf("failed to read body: %s", err)
@@ -52,7 +52,7 @@ func (matcher *HaveHTTPBodyMatcher) FailureMessage(actual interface{}) (message
 	}
 }
 
-func (matcher *HaveHTTPBodyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveHTTPBodyMatcher) NegatedFailureMessage(actual any) (message string) {
 	body, err := matcher.body(actual)
 	if err != nil {
 		return fmt.Sprintf("failed to read body: %s", err)
@@ -73,7 +73,7 @@ func (matcher *HaveHTTPBodyMatcher) NegatedFailureMessage(actual interface{}) (m
 // body returns the body. It is cached because once we read it in Match()
 // the Reader is closed and it is not readable again in FailureMessage()
 // or NegatedFailureMessage()
-func (matcher *HaveHTTPBodyMatcher) body(actual interface{}) ([]byte, error) {
+func (matcher *HaveHTTPBodyMatcher) body(actual any) ([]byte, error) {
 	if matcher.cachedResponse == actual && matcher.cachedBody != nil {
 		return matcher.cachedBody, nil
 	}

e2e/vendor/github.com/onsi/gomega/matchers/have_http_header_with_value_matcher.go

@@ -11,10 +11,10 @@ import (
 
 type HaveHTTPHeaderWithValueMatcher struct {
 	Header string
-	Value  interface{}
+	Value  any
 }
 
-func (matcher *HaveHTTPHeaderWithValueMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveHTTPHeaderWithValueMatcher) Match(actual any) (success bool, err error) {
 	headerValue, err := matcher.extractHeader(actual)
 	if err != nil {
 		return false, err
@@ -28,7 +28,7 @@ func (matcher *HaveHTTPHeaderWithValueMatcher) Match(actual interface{}) (succes
 	return headerMatcher.Match(headerValue)
 }
 
-func (matcher *HaveHTTPHeaderWithValueMatcher) FailureMessage(actual interface{}) string {
+func (matcher *HaveHTTPHeaderWithValueMatcher) FailureMessage(actual any) string {
 	headerValue, err := matcher.extractHeader(actual)
 	if err != nil {
 		panic(err) // protected by Match()
@@ -43,7 +43,7 @@ func (matcher *HaveHTTPHeaderWithValueMatcher) FailureMessage(actual interface{}
 	return fmt.Sprintf("HTTP header %q:\n%s", matcher.Header, diff)
 }
 
-func (matcher *HaveHTTPHeaderWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveHTTPHeaderWithValueMatcher) NegatedFailureMessage(actual any) (message string) {
 	headerValue, err := matcher.extractHeader(actual)
 	if err != nil {
 		panic(err) // protected by Match()
@@ -69,7 +69,7 @@ func (matcher *HaveHTTPHeaderWithValueMatcher) getSubMatcher() (types.GomegaMatc
 	}
 }
 
-func (matcher *HaveHTTPHeaderWithValueMatcher) extractHeader(actual interface{}) (string, error) {
+func (matcher *HaveHTTPHeaderWithValueMatcher) extractHeader(actual any) (string, error) {
 	switch r := actual.(type) {
 	case *http.Response:
 		return r.Header.Get(matcher.Header), nil

e2e/vendor/github.com/onsi/gomega/matchers/have_http_status_matcher.go

@@ -12,10 +12,10 @@ import (
 )
 
 type HaveHTTPStatusMatcher struct {
-	Expected []interface{}
+	Expected []any
 }
 
-func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveHTTPStatusMatcher) Match(actual any) (success bool, err error) {
 	var resp *http.Response
 	switch a := actual.(type) {
 	case *http.Response:
@@ -48,11 +48,11 @@ func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, e
 	return false, nil
 }
 
-func (matcher *HaveHTTPStatusMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveHTTPStatusMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\n%s\n%s", formatHttpResponse(actual), "to have HTTP status", matcher.expectedString())
 }
 
-func (matcher *HaveHTTPStatusMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveHTTPStatusMatcher) NegatedFailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\n%s\n%s", formatHttpResponse(actual), "not to have HTTP status", matcher.expectedString())
 }
 
@@ -64,7 +64,7 @@ func (matcher *HaveHTTPStatusMatcher) expectedString() string {
 	return strings.Join(lines, "\n")
 }
 
-func formatHttpResponse(input interface{}) string {
+func formatHttpResponse(input any) string {
 	var resp *http.Response
 	switch r := input.(type) {
 	case *http.Response:

e2e/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go

@@ -11,10 +11,10 @@ import (
 )
 
 type HaveKeyMatcher struct {
-	Key interface{}
+	Key any
 }
 
-func (matcher *HaveKeyMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveKeyMatcher) Match(actual any) (success bool, err error) {
 	if !isMap(actual) && !miter.IsSeq2(actual) {
 		return false, fmt.Errorf("HaveKey matcher expects a map/iter.Seq2.  Got:%s", format.Object(actual, 1))
 	}
@@ -52,7 +52,7 @@ func (matcher *HaveKeyMatcher) Match(actual interface{}) (success bool, err erro
 	return false, nil
 }
 
-func (matcher *HaveKeyMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveKeyMatcher) FailureMessage(actual any) (message string) {
 	switch matcher.Key.(type) {
 	case omegaMatcher:
 		return format.Message(actual, "to have key matching", matcher.Key)
@@ -61,7 +61,7 @@ func (matcher *HaveKeyMatcher) FailureMessage(actual interface{}) (message strin
 	}
 }
 
-func (matcher *HaveKeyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveKeyMatcher) NegatedFailureMessage(actual any) (message string) {
 	switch matcher.Key.(type) {
 	case omegaMatcher:
 		return format.Message(actual, "not to have key matching", matcher.Key)

e2e/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go

@@ -11,11 +11,11 @@ import (
 )
 
 type HaveKeyWithValueMatcher struct {
-	Key   interface{}
+	Key   any
-	Value interface{}
+	Value any
 }
 
-func (matcher *HaveKeyWithValueMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveKeyWithValueMatcher) Match(actual any) (success bool, err error) {
 	if !isMap(actual) && !miter.IsSeq2(actual) {
 		return false, fmt.Errorf("HaveKeyWithValue matcher expects a map/iter.Seq2.  Got:%s", format.Object(actual, 1))
 	}
@@ -70,7 +70,7 @@ func (matcher *HaveKeyWithValueMatcher) Match(actual interface{}) (success bool,
 	return false, nil
 }
 
-func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual any) (message string) {
 	str := "to have {key: value}"
 	if _, ok := matcher.Key.(omegaMatcher); ok {
 		str += " matching"
@@ -78,12 +78,12 @@ func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual interface{}) (mess
 		str += " matching"
 	}
 
-	expect := make(map[interface{}]interface{}, 1)
+	expect := make(map[any]any, 1)
 	expect[matcher.Key] = matcher.Value
 	return format.Message(actual, str, expect)
 }
 
-func (matcher *HaveKeyWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveKeyWithValueMatcher) NegatedFailureMessage(actual any) (message string) {
 	kStr := "not to have key"
 	if _, ok := matcher.Key.(omegaMatcher); ok {
 		kStr = "not to have key matching"

e2e/vendor/github.com/onsi/gomega/matchers/have_len_matcher.go

@@ -10,7 +10,7 @@ type HaveLenMatcher struct {
 	Count int
 }
 
-func (matcher *HaveLenMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveLenMatcher) Match(actual any) (success bool, err error) {
 	length, ok := lengthOf(actual)
 	if !ok {
 		return false, fmt.Errorf("HaveLen matcher expects a string/array/map/channel/slice/iterator.  Got:\n%s", format.Object(actual, 1))
@@ -19,10 +19,10 @@ func (matcher *HaveLenMatcher) Match(actual interface{}) (success bool, err erro
 	return length == matcher.Count, nil
 }
 
-func (matcher *HaveLenMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveLenMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nto have length %d", format.Object(actual, 1), matcher.Count)
 }
 
-func (matcher *HaveLenMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveLenMatcher) NegatedFailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected\n%s\nnot to have length %d", format.Object(actual, 1), matcher.Count)
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go

@@ -11,7 +11,7 @@ import (
 type HaveOccurredMatcher struct {
 }
 
-func (matcher *HaveOccurredMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveOccurredMatcher) Match(actual any) (success bool, err error) {
 	// is purely nil?
 	if actual == nil {
 		return false, nil
@@ -26,10 +26,10 @@ func (matcher *HaveOccurredMatcher) Match(actual interface{}) (success bool, err
 	return !isNil(actual), nil
 }
 
-func (matcher *HaveOccurredMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveOccurredMatcher) FailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Expected an error to have occurred.  Got:\n%s", format.Object(actual, 1))
 }
 
-func (matcher *HaveOccurredMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveOccurredMatcher) NegatedFailureMessage(actual any) (message string) {
 	return fmt.Sprintf("Unexpected error:\n%s\n%s", format.Object(actual, 1), "occurred")
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher.go

@@ -8,10 +8,10 @@ import (
 
 type HavePrefixMatcher struct {
 	Prefix string
-	Args   []interface{}
+	Args   []any
 }
 
-func (matcher *HavePrefixMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HavePrefixMatcher) Match(actual any) (success bool, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return false, fmt.Errorf("HavePrefix matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
@@ -27,10 +27,10 @@ func (matcher *HavePrefixMatcher) prefix() string {
 	return matcher.Prefix
 }
 
-func (matcher *HavePrefixMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HavePrefixMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to have prefix", matcher.prefix())
 }
 
-func (matcher *HavePrefixMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HavePrefixMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to have prefix", matcher.prefix())
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher.go

@@ -8,10 +8,10 @@ import (
 
 type HaveSuffixMatcher struct {
 	Suffix string
-	Args   []interface{}
+	Args   []any
 }
 
-func (matcher *HaveSuffixMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *HaveSuffixMatcher) Match(actual any) (success bool, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return false, fmt.Errorf("HaveSuffix matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
@@ -27,10 +27,10 @@ func (matcher *HaveSuffixMatcher) suffix() string {
 	return matcher.Suffix
 }
 
-func (matcher *HaveSuffixMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *HaveSuffixMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to have suffix", matcher.suffix())
 }
 
-func (matcher *HaveSuffixMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *HaveSuffixMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to have suffix", matcher.suffix())
 }

e2e/vendor/github.com/onsi/gomega/matchers/have_value.go

@@ -12,10 +12,10 @@ const maxIndirections = 31
 
 type HaveValueMatcher struct {
 	Matcher        types.GomegaMatcher // the matcher to apply to the "resolved" actual value.
-	resolvedActual interface{}         // the ("resolved") value.
+	resolvedActual any                 // the ("resolved") value.
 }
 
-func (m *HaveValueMatcher) Match(actual interface{}) (bool, error) {
+func (m *HaveValueMatcher) Match(actual any) (bool, error) {
 	val := reflect.ValueOf(actual)
 	for allowedIndirs := maxIndirections; allowedIndirs > 0; allowedIndirs-- {
 		// return an error if value isn't valid. Please note that we cannot
@@ -45,10 +45,10 @@ func (m *HaveValueMatcher) Match(actual interface{}) (bool, error) {
 	return false, errors.New(format.Message(actual, "too many indirections"))
 }
 
-func (m *HaveValueMatcher) FailureMessage(_ interface{}) (message string) {
+func (m *HaveValueMatcher) FailureMessage(_ any) (message string) {
 	return m.Matcher.FailureMessage(m.resolvedActual)
 }
 
-func (m *HaveValueMatcher) NegatedFailureMessage(_ interface{}) (message string) {
+func (m *HaveValueMatcher) NegatedFailureMessage(_ any) (message string) {
 	return m.Matcher.NegatedFailureMessage(m.resolvedActual)
 }

e2e/vendor/github.com/onsi/gomega/matchers/match_error_matcher.go

@@ -71,14 +71,14 @@ func (matcher *MatchErrorMatcher) Match(actual any) (success bool, err error) {
 		format.Object(expected, 1))
 }
 
-func (matcher *MatchErrorMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *MatchErrorMatcher) FailureMessage(actual any) (message string) {
 	if matcher.isFunc {
 		return format.Message(actual, fmt.Sprintf("to match error function %s", matcher.FuncErrDescription[0]))
 	}
 	return format.Message(actual, "to match error", matcher.Expected)
 }
 
-func (matcher *MatchErrorMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *MatchErrorMatcher) NegatedFailureMessage(actual any) (message string) {
 	if matcher.isFunc {
 		return format.Message(actual, fmt.Sprintf("not to match error function %s", matcher.FuncErrDescription[0]))
 	}

e2e/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go

@@ -9,18 +9,18 @@ import (
 )
 
 type MatchJSONMatcher struct {
-	JSONToMatch      interface{}
+	JSONToMatch      any
-	firstFailurePath []interface{}
+	firstFailurePath []any
 }
 
-func (matcher *MatchJSONMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *MatchJSONMatcher) Match(actual any) (success bool, err error) {
 	actualString, expectedString, err := matcher.prettyPrint(actual)
 	if err != nil {
 		return false, err
 	}
 
-	var aval interface{}
+	var aval any
-	var eval interface{}
+	var eval any
 
 	// this is guarded by prettyPrint
 	json.Unmarshal([]byte(actualString), &aval)
@@ -30,17 +30,17 @@ func (matcher *MatchJSONMatcher) Match(actual interface{}) (success bool, err er
 	return equal, nil
 }
 
-func (matcher *MatchJSONMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *MatchJSONMatcher) FailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.prettyPrint(actual)
 	return formattedMessage(format.Message(actualString, "to match JSON of", expectedString), matcher.firstFailurePath)
 }
 
-func (matcher *MatchJSONMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *MatchJSONMatcher) NegatedFailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.prettyPrint(actual)
 	return formattedMessage(format.Message(actualString, "not to match JSON of", expectedString), matcher.firstFailurePath)
 }
 
-func (matcher *MatchJSONMatcher) prettyPrint(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+func (matcher *MatchJSONMatcher) prettyPrint(actual any) (actualFormatted, expectedFormatted string, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return "", "", fmt.Errorf("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n%s", format.Object(actual, 1))

e2e/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher.go

@@ -9,10 +9,10 @@ import (
 
 type MatchRegexpMatcher struct {
 	Regexp string
-	Args   []interface{}
+	Args   []any
 }
 
-func (matcher *MatchRegexpMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *MatchRegexpMatcher) Match(actual any) (success bool, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return false, fmt.Errorf("RegExp matcher requires a string or stringer.\nGot:%s", format.Object(actual, 1))
@@ -26,11 +26,11 @@ func (matcher *MatchRegexpMatcher) Match(actual interface{}) (success bool, err
 	return match, nil
 }
 
-func (matcher *MatchRegexpMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *MatchRegexpMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to match regular expression", matcher.regexp())
 }
 
-func (matcher *MatchRegexpMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *MatchRegexpMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "not to match regular expression", matcher.regexp())
 }
 

e2e/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go

@@ -15,10 +15,10 @@ import (
 )
 
 type MatchXMLMatcher struct {
-	XMLToMatch interface{}
+	XMLToMatch any
 }
 
-func (matcher *MatchXMLMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *MatchXMLMatcher) Match(actual any) (success bool, err error) {
 	actualString, expectedString, err := matcher.formattedPrint(actual)
 	if err != nil {
 		return false, err
@@ -37,17 +37,17 @@ func (matcher *MatchXMLMatcher) Match(actual interface{}) (success bool, err err
 	return reflect.DeepEqual(aval, eval), nil
 }
 
-func (matcher *MatchXMLMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *MatchXMLMatcher) FailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.formattedPrint(actual)
 	return fmt.Sprintf("Expected\n%s\nto match XML of\n%s", actualString, expectedString)
 }
 
-func (matcher *MatchXMLMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *MatchXMLMatcher) NegatedFailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.formattedPrint(actual)
 	return fmt.Sprintf("Expected\n%s\nnot to match XML of\n%s", actualString, expectedString)
 }
 
-func (matcher *MatchXMLMatcher) formattedPrint(actual interface{}) (actualString, expectedString string, err error) {
+func (matcher *MatchXMLMatcher) formattedPrint(actual any) (actualString, expectedString string, err error) {
 	var ok bool
 	actualString, ok = toString(actual)
 	if !ok {

e2e/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go

@@ -9,18 +9,18 @@ import (
 )
 
 type MatchYAMLMatcher struct {
-	YAMLToMatch      interface{}
+	YAMLToMatch      any
-	firstFailurePath []interface{}
+	firstFailurePath []any
 }
 
-func (matcher *MatchYAMLMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *MatchYAMLMatcher) Match(actual any) (success bool, err error) {
 	actualString, expectedString, err := matcher.toStrings(actual)
 	if err != nil {
 		return false, err
 	}
 
-	var aval interface{}
+	var aval any
-	var eval interface{}
+	var eval any
 
 	if err := yaml.Unmarshal([]byte(actualString), &aval); err != nil {
 		return false, fmt.Errorf("Actual '%s' should be valid YAML, but it is not.\nUnderlying error:%s", actualString, err)
@@ -34,23 +34,23 @@ func (matcher *MatchYAMLMatcher) Match(actual interface{}) (success bool, err er
 	return equal, nil
 }
 
-func (matcher *MatchYAMLMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *MatchYAMLMatcher) FailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
 	return formattedMessage(format.Message(actualString, "to match YAML of", expectedString), matcher.firstFailurePath)
 }
 
-func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
 	return formattedMessage(format.Message(actualString, "not to match YAML of", expectedString), matcher.firstFailurePath)
 }
 
-func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
 	actualString, expectedString, err := matcher.toStrings(actual)
 	return normalise(actualString), normalise(expectedString), err
 }
 
 func normalise(input string) string {
-	var val interface{}
+	var val any
 	err := yaml.Unmarshal([]byte(input), &val)
 	if err != nil {
 		panic(err) // unreachable since Match already calls Unmarshal
@@ -62,7 +62,7 @@ func normalise(input string) string {
 	return strings.TrimSpace(string(output))
 }
 
-func (matcher *MatchYAMLMatcher) toStrings(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+func (matcher *MatchYAMLMatcher) toStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
 	actualString, ok := toString(actual)
 	if !ok {
 		return "", "", fmt.Errorf("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n%s", format.Object(actual, 1))

e2e/vendor/github.com/onsi/gomega/matchers/not.go

@@ -8,7 +8,7 @@ type NotMatcher struct {
 	Matcher types.GomegaMatcher
 }
 
-func (m *NotMatcher) Match(actual interface{}) (bool, error) {
+func (m *NotMatcher) Match(actual any) (bool, error) {
 	success, err := m.Matcher.Match(actual)
 	if err != nil {
 		return false, err
@@ -16,14 +16,14 @@ func (m *NotMatcher) Match(actual interface{}) (bool, error) {
 	return !success, nil
 }
 
-func (m *NotMatcher) FailureMessage(actual interface{}) (message string) {
+func (m *NotMatcher) FailureMessage(actual any) (message string) {
 	return m.Matcher.NegatedFailureMessage(actual) // works beautifully
 }
 
-func (m *NotMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (m *NotMatcher) NegatedFailureMessage(actual any) (message string) {
 	return m.Matcher.FailureMessage(actual) // works beautifully
 }
 
-func (m *NotMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+func (m *NotMatcher) MatchMayChangeInTheFuture(actual any) bool {
 	return types.MatchMayChangeInTheFuture(m.Matcher, actual) // just return m.Matcher's value
 }

e2e/vendor/github.com/onsi/gomega/matchers/or.go

@@ -14,7 +14,7 @@ type OrMatcher struct {
 	firstSuccessfulMatcher types.GomegaMatcher
 }
 
-func (m *OrMatcher) Match(actual interface{}) (success bool, err error) {
+func (m *OrMatcher) Match(actual any) (success bool, err error) {
 	m.firstSuccessfulMatcher = nil
 	for _, matcher := range m.Matchers {
 		success, err := matcher.Match(actual)
@@ -29,16 +29,16 @@ func (m *OrMatcher) Match(actual interface{}) (success bool, err error) {
 	return false, nil
 }
 
-func (m *OrMatcher) FailureMessage(actual interface{}) (message string) {
+func (m *OrMatcher) FailureMessage(actual any) (message string) {
 	// not the most beautiful list of matchers, but not bad either...
 	return format.Message(actual, fmt.Sprintf("To satisfy at least one of these matchers: %s", m.Matchers))
 }
 
-func (m *OrMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (m *OrMatcher) NegatedFailureMessage(actual any) (message string) {
 	return m.firstSuccessfulMatcher.NegatedFailureMessage(actual)
 }
 
-func (m *OrMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+func (m *OrMatcher) MatchMayChangeInTheFuture(actual any) bool {
 	/*
 		Example with 3 matchers: A, B, C
 

e2e/vendor/github.com/onsi/gomega/matchers/panic_matcher.go

@@ -8,11 +8,11 @@ import (
 )
 
 type PanicMatcher struct {
-	Expected interface{}
+	Expected any
-	object   interface{}
+	object   any
 }
 
-func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *PanicMatcher) Match(actual any) (success bool, err error) {
 	if actual == nil {
 		return false, fmt.Errorf("PanicMatcher expects a non-nil actual.")
 	}
@@ -52,7 +52,7 @@ func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error)
 	return
 }
 
-func (matcher *PanicMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *PanicMatcher) FailureMessage(actual any) (message string) {
 	if matcher.Expected == nil {
 		// We wanted any panic to occur, but none did.
 		return format.Message(actual, "to panic")
@@ -91,7 +91,7 @@ func (matcher *PanicMatcher) FailureMessage(actual interface{}) (message string)
 	}
 }
 
-func (matcher *PanicMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *PanicMatcher) NegatedFailureMessage(actual any) (message string) {
 	if matcher.Expected == nil {
 		// We didn't want any panic to occur, but one did.
 		return format.Message(actual, fmt.Sprintf("not to panic, but panicked with\n%s", format.Object(matcher.object, 1)))

e2e/vendor/github.com/onsi/gomega/matchers/receive_matcher.go

@@ -11,12 +11,12 @@ import (
 )
 
 type ReceiveMatcher struct {
-	Args          []interface{}
+	Args          []any
 	receivedValue reflect.Value
 	channelClosed bool
 }
 
-func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *ReceiveMatcher) Match(actual any) (success bool, err error) {
 	if !isChan(actual) {
 		return false, fmt.Errorf("ReceiveMatcher expects a channel.  Got:\n%s", format.Object(actual, 1))
 	}
@@ -30,7 +30,7 @@ func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err erro
 
 	var subMatcher omegaMatcher
 	var hasSubMatcher bool
-	var resultReference interface{}
+	var resultReference any
 
 	// Valid arg formats are as follows, always with optional POINTER before
 	// optional MATCHER:
@@ -115,8 +115,8 @@ func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err erro
 	return false, nil
 }
 
-func (matcher *ReceiveMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *ReceiveMatcher) FailureMessage(actual any) (message string) {
-	var matcherArg interface{}
+	var matcherArg any
 	if len(matcher.Args) > 0 {
 		matcherArg = matcher.Args[len(matcher.Args)-1]
 	}
@@ -136,8 +136,8 @@ func (matcher *ReceiveMatcher) FailureMessage(actual interface{}) (message strin
 	return format.Message(actual, "to receive something."+closedAddendum)
 }
 
-func (matcher *ReceiveMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *ReceiveMatcher) NegatedFailureMessage(actual any) (message string) {
-	var matcherArg interface{}
+	var matcherArg any
 	if len(matcher.Args) > 0 {
 		matcherArg = matcher.Args[len(matcher.Args)-1]
 	}
@@ -157,7 +157,7 @@ func (matcher *ReceiveMatcher) NegatedFailureMessage(actual interface{}) (messag
 	return format.Message(actual, "not to receive anything."+closedAddendum)
 }
 
-func (matcher *ReceiveMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+func (matcher *ReceiveMatcher) MatchMayChangeInTheFuture(actual any) bool {
 	if !isChan(actual) {
 		return false
 	}

e2e/vendor/github.com/onsi/gomega/matchers/satisfy_matcher.go

@@ -8,13 +8,13 @@ import (
 )
 
 type SatisfyMatcher struct {
-	Predicate interface{}
+	Predicate any
 
 	// cached type
 	predicateArgType reflect.Type
 }
 
-func NewSatisfyMatcher(predicate interface{}) *SatisfyMatcher {
+func NewSatisfyMatcher(predicate any) *SatisfyMatcher {
 	if predicate == nil {
 		panic("predicate cannot be nil")
 	}
@@ -35,7 +35,7 @@ func NewSatisfyMatcher(predicate interface{}) *SatisfyMatcher {
 	}
 }
 
-func (m *SatisfyMatcher) Match(actual interface{}) (success bool, err error) {
+func (m *SatisfyMatcher) Match(actual any) (success bool, err error) {
 	// prepare a parameter to pass to the predicate
 	var param reflect.Value
 	if actual != nil && reflect.TypeOf(actual).AssignableTo(m.predicateArgType) {
@@ -57,10 +57,10 @@ func (m *SatisfyMatcher) Match(actual interface{}) (success bool, err error) {
 	return result[0].Bool(), nil
 }
 
-func (m *SatisfyMatcher) FailureMessage(actual interface{}) (message string) {
+func (m *SatisfyMatcher) FailureMessage(actual any) (message string) {
 	return format.Message(actual, "to satisfy predicate", m.Predicate)
 }
 
-func (m *SatisfyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (m *SatisfyMatcher) NegatedFailureMessage(actual any) (message string) {
 	return format.Message(actual, "to not satisfy predicate", m.Predicate)
 }

e2e/vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 )
 
-func formattedMessage(comparisonMessage string, failurePath []interface{}) string {
+func formattedMessage(comparisonMessage string, failurePath []any) string {
 	var diffMessage string
 	if len(failurePath) == 0 {
 		diffMessage = ""
@@ -18,7 +18,7 @@ func formattedMessage(comparisonMessage string, failurePath []interface{}) strin
 	return fmt.Sprintf("%s%s", comparisonMessage, diffMessage)
 }
 
-func formattedFailurePath(failurePath []interface{}) string {
+func formattedFailurePath(failurePath []any) string {
 	formattedPaths := []string{}
 	for i := len(failurePath) - 1; i >= 0; i-- {
 		switch p := failurePath[i].(type) {
@@ -34,33 +34,33 @@ func formattedFailurePath(failurePath []interface{}) string {
 	return strings.Join(formattedPaths, "")
 }
 
-func deepEqual(a interface{}, b interface{}) (bool, []interface{}) {
+func deepEqual(a any, b any) (bool, []any) {
-	var errorPath []interface{}
+	var errorPath []any
 	if reflect.TypeOf(a) != reflect.TypeOf(b) {
 		return false, errorPath
 	}
 
 	switch a.(type) {
-	case []interface{}:
+	case []any:
-		if len(a.([]interface{})) != len(b.([]interface{})) {
+		if len(a.([]any)) != len(b.([]any)) {
 			return false, errorPath
 		}
 
-		for i, v := range a.([]interface{}) {
+		for i, v := range a.([]any) {
-			elementEqual, keyPath := deepEqual(v, b.([]interface{})[i])
+			elementEqual, keyPath := deepEqual(v, b.([]any)[i])
 			if !elementEqual {
 				return false, append(keyPath, i)
 			}
 		}
 		return true, errorPath
 
-	case map[interface{}]interface{}:
+	case map[any]any:
-		if len(a.(map[interface{}]interface{})) != len(b.(map[interface{}]interface{})) {
+		if len(a.(map[any]any)) != len(b.(map[any]any)) {
 			return false, errorPath
 		}
 
-		for k, v1 := range a.(map[interface{}]interface{}) {
+		for k, v1 := range a.(map[any]any) {
-			v2, ok := b.(map[interface{}]interface{})[k]
+			v2, ok := b.(map[any]any)[k]
 			if !ok {
 				return false, errorPath
 			}
@@ -71,13 +71,13 @@ func deepEqual(a interface{}, b interface{}) (bool, []interface{}) {
 		}
 		return true, errorPath
 
-	case map[string]interface{}:
+	case map[string]any:
-		if len(a.(map[string]interface{})) != len(b.(map[string]interface{})) {
+		if len(a.(map[string]any)) != len(b.(map[string]any)) {
 			return false, errorPath
 		}
 
-		for k, v1 := range a.(map[string]interface{}) {
+		for k, v1 := range a.(map[string]any) {
-			v2, ok := b.(map[string]interface{})[k]
+			v2, ok := b.(map[string]any)[k]
 			if !ok {
 				return false, errorPath
 			}

e2e/vendor/github.com/onsi/gomega/matchers/succeed_matcher.go

@@ -14,7 +14,7 @@ type formattedGomegaError interface {
 type SucceedMatcher struct {
 }
 
-func (matcher *SucceedMatcher) Match(actual interface{}) (success bool, err error) {
+func (matcher *SucceedMatcher) Match(actual any) (success bool, err error) {
 	// is purely nil?
 	if actual == nil {
 		return true, nil
@@ -29,7 +29,7 @@ func (matcher *SucceedMatcher) Match(actual interface{}) (success bool, err erro
 	return isNil(actual), nil
 }
 
-func (matcher *SucceedMatcher) FailureMessage(actual interface{}) (message string) {
+func (matcher *SucceedMatcher) FailureMessage(actual any) (message string) {
 	var fgErr formattedGomegaError
 	if errors.As(actual.(error), &fgErr) {
 		return fgErr.FormattedGomegaError()
@@ -37,6 +37,6 @@ func (matcher *SucceedMatcher) FailureMessage(actual interface{}) (message strin
 	return fmt.Sprintf("Expected success, but got an error:\n%s", format.Object(actual, 1))
 }
 
-func (matcher *SucceedMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+func (matcher *SucceedMatcher) NegatedFailureMessage(actual any) (message string) {
 	return "Expected failure, but got no error."
 }

e2e/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go

@@ -11,7 +11,7 @@ type BipartiteGraph struct {
 	Edges EdgeSet
 }
 
-func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(interface{}, interface{}) (bool, error)) (*BipartiteGraph, error) {
+func NewBipartiteGraph(leftValues, rightValues []any, neighbours func(any, any) (bool, error)) (*BipartiteGraph, error) {
 	left := NodeOrderedSet{}
 	for i, v := range leftValues {
 		left = append(left, Node{ID: i, Value: v})
@@ -41,7 +41,7 @@ func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(in
 
 // FreeLeftRight returns left node values and right node values
 // of the BipartiteGraph's nodes which are not part of the given edges.
-func (bg *BipartiteGraph) FreeLeftRight(edges EdgeSet) (leftValues, rightValues []interface{}) {
+func (bg *BipartiteGraph) FreeLeftRight(edges EdgeSet) (leftValues, rightValues []any) {
 	for _, node := range bg.Left {
 		if edges.Free(node) {
 			leftValues = append(leftValues, node.Value)

e2e/vendor/github.com/onsi/gomega/matchers/support/goraph/node/node.go

@@ -2,7 +2,7 @@ package node
 
 type Node struct {
 	ID    int
-	Value interface{}
+	Value any
 }
 
 type NodeOrderedSet []Node

e2e/vendor/github.com/onsi/gomega/matchers/type_support.go

@@ -20,16 +20,16 @@ import (
 )
 
 type omegaMatcher interface {
-	Match(actual interface{}) (success bool, err error)
+	Match(actual any) (success bool, err error)
-	FailureMessage(actual interface{}) (message string)
+	FailureMessage(actual any) (message string)
-	NegatedFailureMessage(actual interface{}) (message string)
+	NegatedFailureMessage(actual any) (message string)
 }
 
-func isBool(a interface{}) bool {
+func isBool(a any) bool {
 	return reflect.TypeOf(a).Kind() == reflect.Bool
 }
 
-func isNumber(a interface{}) bool {
+func isNumber(a any) bool {
 	if a == nil {
 		return false
 	}
@@ -37,22 +37,22 @@ func isNumber(a interface{}) bool {
 	return reflect.Int <= kind && kind <= reflect.Float64
 }
 
-func isInteger(a interface{}) bool {
+func isInteger(a any) bool {
 	kind := reflect.TypeOf(a).Kind()
 	return reflect.Int <= kind && kind <= reflect.Int64
 }
 
-func isUnsignedInteger(a interface{}) bool {
+func isUnsignedInteger(a any) bool {
 	kind := reflect.TypeOf(a).Kind()
 	return reflect.Uint <= kind && kind <= reflect.Uint64
 }
 
-func isFloat(a interface{}) bool {
+func isFloat(a any) bool {
 	kind := reflect.TypeOf(a).Kind()
 	return reflect.Float32 <= kind && kind <= reflect.Float64
 }
 
-func toInteger(a interface{}) int64 {
+func toInteger(a any) int64 {
 	if isInteger(a) {
 		return reflect.ValueOf(a).Int()
 	} else if isUnsignedInteger(a) {
@@ -63,7 +63,7 @@ func toInteger(a interface{}) int64 {
 	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
 }
 
-func toUnsignedInteger(a interface{}) uint64 {
+func toUnsignedInteger(a any) uint64 {
 	if isInteger(a) {
 		return uint64(reflect.ValueOf(a).Int())
 	} else if isUnsignedInteger(a) {
@@ -74,7 +74,7 @@ func toUnsignedInteger(a interface{}) uint64 {
 	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
 }
 
-func toFloat(a interface{}) float64 {
+func toFloat(a any) float64 {
 	if isInteger(a) {
 		return float64(reflect.ValueOf(a).Int())
 	} else if isUnsignedInteger(a) {
@@ -85,26 +85,26 @@ func toFloat(a interface{}) float64 {
 	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
 }
 
-func isError(a interface{}) bool {
+func isError(a any) bool {
 	_, ok := a.(error)
 	return ok
 }
 
-func isChan(a interface{}) bool {
+func isChan(a any) bool {
 	if isNil(a) {
 		return false
 	}
 	return reflect.TypeOf(a).Kind() == reflect.Chan
 }
 
-func isMap(a interface{}) bool {
+func isMap(a any) bool {
 	if a == nil {
 		return false
 	}
 	return reflect.TypeOf(a).Kind() == reflect.Map
 }
 
-func isArrayOrSlice(a interface{}) bool {
+func isArrayOrSlice(a any) bool {
 	if a == nil {
 		return false
 	}
@@ -116,14 +116,14 @@ func isArrayOrSlice(a interface{}) bool {
 	}
 }
 
-func isString(a interface{}) bool {
+func isString(a any) bool {
 	if a == nil {
 		return false
 	}
 	return reflect.TypeOf(a).Kind() == reflect.String
 }
 
-func toString(a interface{}) (string, bool) {
+func toString(a any) (string, bool) {
 	aString, isString := a.(string)
 	if isString {
 		return aString, true
@@ -147,7 +147,7 @@ func toString(a interface{}) (string, bool) {
 	return "", false
 }
 
-func lengthOf(a interface{}) (int, bool) {
+func lengthOf(a any) (int, bool) {
 	if a == nil {
 		return 0, false
 	}
@@ -169,7 +169,7 @@ func lengthOf(a interface{}) (int, bool) {
 		return 0, false
 	}
 }
-func capOf(a interface{}) (int, bool) {
+func capOf(a any) (int, bool) {
 	if a == nil {
 		return 0, false
 	}
@@ -181,7 +181,7 @@ func capOf(a interface{}) (int, bool) {
 	}
 }
 
-func isNil(a interface{}) bool {
+func isNil(a any) bool {
 	if a == nil {
 		return true
 	}

e2e/vendor/github.com/onsi/gomega/matchers/with_transform.go

@@ -9,20 +9,20 @@ import (
 
 type WithTransformMatcher struct {
 	// input
-	Transform interface{} // must be a function of one parameter that returns one value and an optional error
+	Transform any // must be a function of one parameter that returns one value and an optional error
 	Matcher   types.GomegaMatcher
 
 	// cached value
 	transformArgType reflect.Type
 
 	// state
-	transformedValue interface{}
+	transformedValue any
 }
 
 // reflect.Type for error
 var errorT = reflect.TypeOf((*error)(nil)).Elem()
 
-func NewWithTransformMatcher(transform interface{}, matcher types.GomegaMatcher) *WithTransformMatcher {
+func NewWithTransformMatcher(transform any, matcher types.GomegaMatcher) *WithTransformMatcher {
 	if transform == nil {
 		panic("transform function cannot be nil")
 	}
@@ -43,7 +43,7 @@ func NewWithTransformMatcher(transform interface{}, matcher types.GomegaMatcher)
 	}
 }
 
-func (m *WithTransformMatcher) Match(actual interface{}) (bool, error) {
+func (m *WithTransformMatcher) Match(actual any) (bool, error) {
 	// prepare a parameter to pass to the Transform function
 	var param reflect.Value
 	if actual != nil && reflect.TypeOf(actual).AssignableTo(m.transformArgType) {
@@ -72,15 +72,15 @@ func (m *WithTransformMatcher) Match(actual interface{}) (bool, error) {
 	return m.Matcher.Match(m.transformedValue)
 }
 
-func (m *WithTransformMatcher) FailureMessage(_ interface{}) (message string) {
+func (m *WithTransformMatcher) FailureMessage(_ any) (message string) {
 	return m.Matcher.FailureMessage(m.transformedValue)
 }
 
-func (m *WithTransformMatcher) NegatedFailureMessage(_ interface{}) (message string) {
+func (m *WithTransformMatcher) NegatedFailureMessage(_ any) (message string) {
 	return m.Matcher.NegatedFailureMessage(m.transformedValue)
 }
 
-func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ interface{}) bool {
+func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ any) bool {
 	// TODO: Maybe this should always just return true? (Only an issue for non-deterministic transformers.)
 	//
 	// Querying the next matcher is fine if the transformer always will return the same value.

e2e/vendor/github.com/onsi/gomega/types/types.go

@@ -10,20 +10,20 @@ type GomegaFailHandler func(message string, callerSkip ...int)
 // A simple *testing.T interface wrapper
 type GomegaTestingT interface {
 	Helper()
-	Fatalf(format string, args ...interface{})
+	Fatalf(format string, args ...any)
 }
 
-// Gomega represents an object that can perform synchronous and assynchronous assertions with Gomega matchers
+// Gomega represents an object that can perform synchronous and asynchronous assertions with Gomega matchers
 type Gomega interface {
-	Ω(actual interface{}, extra ...interface{}) Assertion
+	Ω(actual any, extra ...any) Assertion
-	Expect(actual interface{}, extra ...interface{}) Assertion
+	Expect(actual any, extra ...any) Assertion
-	ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Assertion
+	ExpectWithOffset(offset int, actual any, extra ...any) Assertion
 
-	Eventually(actualOrCtx interface{}, args ...interface{}) AsyncAssertion
+	Eventually(actualOrCtx any, args ...any) AsyncAssertion
-	EventuallyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) AsyncAssertion
+	EventuallyWithOffset(offset int, actualOrCtx any, args ...any) AsyncAssertion
 
-	Consistently(actualOrCtx interface{}, args ...interface{}) AsyncAssertion
+	Consistently(actualOrCtx any, args ...any) AsyncAssertion
-	ConsistentlyWithOffset(offset int, actualOrCtx interface{}, args ...interface{}) AsyncAssertion
+	ConsistentlyWithOffset(offset int, actualOrCtx any, args ...any) AsyncAssertion
 
 	SetDefaultEventuallyTimeout(time.Duration)
 	SetDefaultEventuallyPollingInterval(time.Duration)
@@ -37,9 +37,9 @@ type Gomega interface {
 //
 // For details on writing custom matchers, check out: http://onsi.github.io/gomega/#adding-your-own-matchers
 type GomegaMatcher interface {
-	Match(actual interface{}) (success bool, err error)
+	Match(actual any) (success bool, err error)
-	FailureMessage(actual interface{}) (message string)
+	FailureMessage(actual any) (message string)
-	NegatedFailureMessage(actual interface{}) (message string)
+	NegatedFailureMessage(actual any) (message string)
 }
 
 /*
@@ -52,10 +52,10 @@ For example, a process' exit code can never change.  So, gexec's Exit matcher re
 for `MatchMayChangeInTheFuture` until the process exits, at which point it returns `false` forevermore.
 */
 type OracleMatcher interface {
-	MatchMayChangeInTheFuture(actual interface{}) bool
+	MatchMayChangeInTheFuture(actual any) bool
 }
 
-func MatchMayChangeInTheFuture(matcher GomegaMatcher, value interface{}) bool {
+func MatchMayChangeInTheFuture(matcher GomegaMatcher, value any) bool {
 	oracleMatcher, ok := matcher.(OracleMatcher)
 	if !ok {
 		return true
@@ -67,8 +67,8 @@ func MatchMayChangeInTheFuture(matcher GomegaMatcher, value interface{}) bool {
 // AsyncAssertions are returned by Eventually and Consistently and enable matchers to be polled repeatedly to ensure
 // they are eventually satisfied
 type AsyncAssertion interface {
-	Should(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	Should(matcher GomegaMatcher, optionalDescription ...any) bool
-	ShouldNot(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	ShouldNot(matcher GomegaMatcher, optionalDescription ...any) bool
 
 	WithOffset(offset int) AsyncAssertion
 	WithTimeout(interval time.Duration) AsyncAssertion
@@ -76,18 +76,18 @@ type AsyncAssertion interface {
 	Within(timeout time.Duration) AsyncAssertion
 	ProbeEvery(interval time.Duration) AsyncAssertion
 	WithContext(ctx context.Context) AsyncAssertion
-	WithArguments(argsToForward ...interface{}) AsyncAssertion
+	WithArguments(argsToForward ...any) AsyncAssertion
 	MustPassRepeatedly(count int) AsyncAssertion
 }
 
 // Assertions are returned by Ω and Expect and enable assertions against Gomega matchers
 type Assertion interface {
-	Should(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	Should(matcher GomegaMatcher, optionalDescription ...any) bool
-	ShouldNot(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	ShouldNot(matcher GomegaMatcher, optionalDescription ...any) bool
 
-	To(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	To(matcher GomegaMatcher, optionalDescription ...any) bool
-	ToNot(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	ToNot(matcher GomegaMatcher, optionalDescription ...any) bool
-	NotTo(matcher GomegaMatcher, optionalDescription ...interface{}) bool
+	NotTo(matcher GomegaMatcher, optionalDescription ...any) bool
 
 	WithOffset(offset int) Assertion
 

e2e/vendor/modules.txt

@@ -198,8 +198,8 @@ github.com/google/gnostic-models/extensions
 github.com/google/gnostic-models/jsonschema
 github.com/google/gnostic-models/openapiv2
 github.com/google/gnostic-models/openapiv3
-# github.com/google/go-cmp v0.6.0
+# github.com/google/go-cmp v0.7.0
-## explicit; go 1.13
+## explicit; go 1.21
 github.com/google/go-cmp/cmp
 github.com/google/go-cmp/cmp/cmpopts
 github.com/google/go-cmp/cmp/internal/diff
@@ -288,7 +288,7 @@ github.com/munnerz/goautoneg
 # github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f
 ## explicit
 github.com/mxk/go-flowrate/flowrate
-# github.com/onsi/ginkgo/v2 v2.23.0
+# github.com/onsi/ginkgo/v2 v2.23.3
 ## explicit; go 1.23.0
 github.com/onsi/ginkgo/v2
 github.com/onsi/ginkgo/v2/config
@@ -310,8 +310,8 @@ github.com/onsi/ginkgo/v2/internal/parallel_support
 github.com/onsi/ginkgo/v2/internal/testingtproxy
 github.com/onsi/ginkgo/v2/reporters
 github.com/onsi/ginkgo/v2/types
-# github.com/onsi/gomega v1.36.2
+# github.com/onsi/gomega v1.36.3
-## explicit; go 1.22.0
+## explicit; go 1.23.0
 github.com/onsi/gomega
 github.com/onsi/gomega/format
 github.com/onsi/gomega/gcustom