Replace `interface{}` with `any` (#25686)

Result of running `perl -p -i -e 's#interface\{\}#any#g' **/*` and `make fmt`.

Basically the same [as golang did](https://github.com/golang/go/commit/2580d0e08d5e9f979b943758d3c49877fb2324cb).

build/code-batch-process.go

···
 
 var optionLogVerbose bool
 
-func logVerbose(msg string, args ...interface{}) {
+func logVerbose(msg string, args ...any) {
 	if optionLogVerbose {
 		log.Printf(msg, args...)
 	}

cmd/cert.go

···
 	},
 }
 
-func publicKey(priv interface{}) interface{} {
+func publicKey(priv any) any {
 	switch k := priv.(type) {
 	case *rsa.PrivateKey:
 		return &k.PublicKey
···
 	}
 }
 
-func pemBlockForKey(priv interface{}) *pem.Block {
+func pemBlockForKey(priv any) *pem.Block {
 	switch k := priv.(type) {
 	case *rsa.PrivateKey:
 		return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}
···
 		return err
 	}
 
-	var priv interface{}
+	var priv any
 	var err error
 	switch c.String("ecdsa-curve") {
 	case "":

cmd/dump.go

···
 	},
 }
 
-func fatal(format string, args ...interface{}) {
+func fatal(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, format+"\n", args...)
 	log.Fatal(format, args...)
 }
···
 		return err
 	}
 
-	var iface interface{}
+	var iface any
 	if fileName == "-" {
 		iface, err = archiver.ByExtension(fmt.Sprintf(".%s", outType))
 	} else {

cmd/manager_logging.go

···
 	defer cancel()
 
 	setup(ctx, c.Bool("debug"))
-	vals := map[string]interface{}{}
+	vals := map[string]any{}
 	mode := "conn"
 	vals["net"] = "tcp"
 	if c.IsSet("protocol") {
···
 	defer cancel()
 
 	setup(ctx, c.Bool("debug"))
-	vals := map[string]interface{}{}
+	vals := map[string]any{}
 	mode := "file"
 	if c.IsSet("filename") {
 		vals["filename"] = c.String("filename")
···
 	return commonAddLogger(c, mode, vals)
 }
 
-func commonAddLogger(c *cli.Context, mode string, vals map[string]interface{}) error {
+func commonAddLogger(c *cli.Context, mode string, vals map[string]any) error {
 	if len(c.String("level")) > 0 {
 		vals["level"] = log.LevelFromString(c.String("level")).String()
 	}

cmd/serv.go

···
 
 // fail prints message to stdout, it's mainly used for git serv and git hook commands.
 // The output will be passed to git client and shown to user.
-func fail(ctx context.Context, userMessage, logMsgFmt string, args ...interface{}) error {
+func fail(ctx context.Context, userMessage, logMsgFmt string, args ...any) error {
 	if userMessage == "" {
 		userMessage = "Internal Server Error (no specific error)"
 	}

models/admin/task.go

···
 // TranslatableMessage represents JSON struct that can be translated with a Locale
 type TranslatableMessage struct {
 	Format string
-	Args   []interface{} `json:"omitempty"`
+	Args   []any `json:"omitempty"`
 }
 
 // LoadRepo loads repository of the task

models/asymkey/ssh_key_authorized_keys.go

···
 // AuthorizedStringForKey creates the authorized keys string appropriate for the provided key
 func AuthorizedStringForKey(key *PublicKey) string {
 	sb := &strings.Builder{}
-	_ = setting.SSH.AuthorizedKeysCommandTemplateTemplate.Execute(sb, map[string]interface{}{
+	_ = setting.SSH.AuthorizedKeysCommandTemplateTemplate.Execute(sb, map[string]any{
 		"AppPath":     util.ShellEscape(setting.AppPath),
 		"AppWorkPath": util.ShellEscape(setting.AppWorkPath),
 		"CustomConf":  util.ShellEscape(setting.CustomConf),
···
 
 // RegeneratePublicKeys regenerates the authorized_keys file
 func RegeneratePublicKeys(ctx context.Context, t io.StringWriter) error {
-	if err := db.GetEngine(ctx).Where("type != ?", KeyTypePrincipal).Iterate(new(PublicKey), func(idx int, bean interface{}) (err error) {
+	if err := db.GetEngine(ctx).Where("type != ?", KeyTypePrincipal).Iterate(new(PublicKey), func(idx int, bean any) (err error) {
 		_, err = t.WriteString((bean.(*PublicKey)).AuthorizedString())
 		return err
 	}); err != nil {

models/asymkey/ssh_key_authorized_principals.go

···
 }
 
 func regeneratePrincipalKeys(ctx context.Context, t io.StringWriter) error {
-	if err := db.GetEngine(ctx).Where("type = ?", KeyTypePrincipal).Iterate(new(PublicKey), func(idx int, bean interface{}) (err error) {
+	if err := db.GetEngine(ctx).Where("type = ?", KeyTypePrincipal).Iterate(new(PublicKey), func(idx int, bean any) (err error) {
 		_, err = t.WriteString((bean.(*PublicKey)).AuthorizedString())
 		return err
 	}); err != nil {

models/db/context.go

···
 }
 
 // Value shadows Value for context.Context but allows us to get ourselves and an Engined object
-func (ctx *Context) Value(key interface{}) interface{} {
+func (ctx *Context) Value(key any) any {
 	if key == enginedContextKey {
 		return ctx
 	}
···
 }
 
 // Insert inserts records into database
-func Insert(ctx context.Context, beans ...interface{}) error {
+func Insert(ctx context.Context, beans ...any) error {
 	_, err := GetEngine(ctx).Insert(beans...)
 	return err
 }
 
 // Exec executes a sql with args
-func Exec(ctx context.Context, sqlAndArgs ...interface{}) (sql.Result, error) {
+func Exec(ctx context.Context, sqlAndArgs ...any) (sql.Result, error) {
 	return GetEngine(ctx).Exec(sqlAndArgs...)
 }
 
 // GetByBean filled empty fields of the bean according non-empty fields to query in database.
-func GetByBean(ctx context.Context, bean interface{}) (bool, error) {
+func GetByBean(ctx context.Context, bean any) (bool, error) {
 	return GetEngine(ctx).Get(bean)
 }
 
 // DeleteByBean deletes all records according non-empty fields of the bean as conditions.
-func DeleteByBean(ctx context.Context, bean interface{}) (int64, error) {
+func DeleteByBean(ctx context.Context, bean any) (int64, error) {
 	return GetEngine(ctx).Delete(bean)
 }
 
 // DeleteByID deletes the given bean with the given ID
-func DeleteByID(ctx context.Context, id int64, bean interface{}) (int64, error) {
+func DeleteByID(ctx context.Context, id int64, bean any) (int64, error) {
 	return GetEngine(ctx).ID(id).NoAutoTime().Delete(bean)
 }
 
···
 
 // DecrByIDs decreases the given column for entities of the "bean" type with one of the given ids by one
 // Timestamps of the entities won't be updated
-func DecrByIDs(ctx context.Context, ids []int64, decrCol string, bean interface{}) error {
+func DecrByIDs(ctx context.Context, ids []int64, decrCol string, bean any) error {
 	_, err := GetEngine(ctx).Decr(decrCol).In("id", ids).NoAutoCondition().NoAutoTime().Update(bean)
 	return err
 }
 
 // DeleteBeans deletes all given beans, beans must contain delete conditions.
-func DeleteBeans(ctx context.Context, beans ...interface{}) (err error) {
+func DeleteBeans(ctx context.Context, beans ...any) (err error) {
 	e := GetEngine(ctx)
 	for i := range beans {
 		if _, err = e.Delete(beans[i]); err != nil {
···
 }
 
 // TruncateBeans deletes all given beans, beans may contain delete conditions.
-func TruncateBeans(ctx context.Context, beans ...interface{}) (err error) {
+func TruncateBeans(ctx context.Context, beans ...any) (err error) {
 	e := GetEngine(ctx)
 	for i := range beans {
 		if _, err = e.Truncate(beans[i]); err != nil {
···
 }
 
 // CountByBean counts the number of database records according non-empty fields of the bean as conditions.
-func CountByBean(ctx context.Context, bean interface{}) (int64, error) {
+func CountByBean(ctx context.Context, bean any) (int64, error) {
 	return GetEngine(ctx).Count(bean)
 }
 
 // TableName returns the table name according a bean object
-func TableName(bean interface{}) string {
+func TableName(bean any) string {
 	return x.TableName(bean)
 }
 

models/db/engine.go

···
 
 var (
 	x         *xorm.Engine
-	tables    []interface{}
+	tables    []any
 	initFuncs []func() error
 
 	// HasEngine specifies if we have a xorm.Engine
···
 
 // Engine represents a xorm engine or session.
 type Engine interface {
-	Table(tableNameOrBean interface{}) *xorm.Session
-	Count(...interface{}) (int64, error)
-	Decr(column string, arg ...interface{}) *xorm.Session
-	Delete(...interface{}) (int64, error)
-	Truncate(...interface{}) (int64, error)
-	Exec(...interface{}) (sql.Result, error)
-	Find(interface{}, ...interface{}) error
-	Get(beans ...interface{}) (bool, error)
-	ID(interface{}) *xorm.Session
-	In(string, ...interface{}) *xorm.Session
-	Incr(column string, arg ...interface{}) *xorm.Session
-	Insert(...interface{}) (int64, error)
-	Iterate(interface{}, xorm.IterFunc) error
-	Join(joinOperator string, tablename, condition interface{}, args ...interface{}) *xorm.Session
-	SQL(interface{}, ...interface{}) *xorm.Session
-	Where(interface{}, ...interface{}) *xorm.Session
+	Table(tableNameOrBean any) *xorm.Session
+	Count(...any) (int64, error)
+	Decr(column string, arg ...any) *xorm.Session
+	Delete(...any) (int64, error)
+	Truncate(...any) (int64, error)
+	Exec(...any) (sql.Result, error)
+	Find(any, ...any) error
+	Get(beans ...any) (bool, error)
+	ID(any) *xorm.Session
+	In(string, ...any) *xorm.Session
+	Incr(column string, arg ...any) *xorm.Session
+	Insert(...any) (int64, error)
+	Iterate(any, xorm.IterFunc) error
+	Join(joinOperator string, tablename, condition any, args ...any) *xorm.Session
+	SQL(any, ...any) *xorm.Session
+	Where(any, ...any) *xorm.Session
 	Asc(colNames ...string) *xorm.Session
 	Desc(colNames ...string) *xorm.Session
 	Limit(limit int, start ...int) *xorm.Session
 	NoAutoTime() *xorm.Session
-	SumInt(bean interface{}, columnName string) (res int64, err error)
-	Sync2(...interface{}) error
+	SumInt(bean any, columnName string) (res int64, err error)
+	Sync2(...any) error
 	Select(string) *xorm.Session
-	NotIn(string, ...interface{}) *xorm.Session
-	OrderBy(interface{}, ...interface{}) *xorm.Session
-	Exist(...interface{}) (bool, error)
+	NotIn(string, ...any) *xorm.Session
+	OrderBy(any, ...any) *xorm.Session
+	Exist(...any) (bool, error)
 	Distinct(...string) *xorm.Session
-	Query(...interface{}) ([]map[string][]byte, error)
+	Query(...any) ([]map[string][]byte, error)
 	Cols(...string) *xorm.Session
 	Context(ctx context.Context) *xorm.Session
 	Ping() error
 }
 
 // TableInfo returns table's information via an object
-func TableInfo(v interface{}) (*schemas.Table, error) {
+func TableInfo(v any) (*schemas.Table, error) {
 	return x.TableInfo(v)
 }
 
···
 }
 
 // RegisterModel registers model, if initfunc provided, it will be invoked after data model sync
-func RegisterModel(bean interface{}, initFunc ...func() error) {
+func RegisterModel(bean any, initFunc ...func() error) {
 	tables = append(tables, bean)
 	if len(initFuncs) > 0 && initFunc[0] != nil {
 		initFuncs = append(initFuncs, initFunc[0])
···
 }
 
 // NamesToBean return a list of beans or an error
-func NamesToBean(names ...string) ([]interface{}, error) {
-	beans := []interface{}{}
+func NamesToBean(names ...string) ([]any, error) {
+	beans := []any{}
 	if len(names) == 0 {
 		beans = append(beans, tables...)
 		return beans, nil
 	}
 	// Need to map provided names to beans...
-	beanMap := make(map[string]interface{})
+	beanMap := make(map[string]any)
 	for _, bean := range tables {
 
 		beanMap[strings.ToLower(reflect.Indirect(reflect.ValueOf(bean)).Type().Name())] = bean
···
 		beanMap[strings.ToLower(x.TableName(bean, true))] = bean
 	}
 
-	gotBean := make(map[interface{}]bool)
+	gotBean := make(map[any]bool)
 	for _, name := range names {
 		bean, ok := beanMap[strings.ToLower(strings.TrimSpace(name))]
 		if !ok {
···
 }
 
 // MaxBatchInsertSize returns the table's max batch insert size
-func MaxBatchInsertSize(bean interface{}) int {
+func MaxBatchInsertSize(bean any) int {
 	t, err := x.TableInfo(bean)
 	if err != nil {
 		return 50
···
 }
 
 // GetMaxID will return max id of the table
-func GetMaxID(beanOrTableName interface{}) (maxID int64, err error) {
+func GetMaxID(beanOrTableName any) (maxID int64, err error) {
 	_, err = x.Select("MAX(id)").Table(beanOrTableName).Get(&maxID)
 	return maxID, err
 }

models/db/error.go

···
 }
 
 // ErrCancelledf returns an ErrCancelled for the provided format and args
-func ErrCancelledf(format string, args ...interface{}) error {
+func ErrCancelledf(format string, args ...any) error {
 	return ErrCancelled{
 		fmt.Sprintf(format, args...),
 	}

models/db/log.go

···
 const stackLevel = 8
 
 // Log a message with defined skip and at logging level
-func (l *XORMLogBridge) Log(skip int, level log.Level, format string, v ...interface{}) {
+func (l *XORMLogBridge) Log(skip int, level log.Level, format string, v ...any) {
 	l.logger.Log(skip+1, level, format, v...)
 }
 
 // Debug show debug log
-func (l *XORMLogBridge) Debug(v ...interface{}) {
+func (l *XORMLogBridge) Debug(v ...any) {
 	l.Log(stackLevel, log.DEBUG, "%s", fmt.Sprint(v...))
 }
 
 // Debugf show debug log
-func (l *XORMLogBridge) Debugf(format string, v ...interface{}) {
+func (l *XORMLogBridge) Debugf(format string, v ...any) {
 	l.Log(stackLevel, log.DEBUG, format, v...)
 }
 
 // Error show error log
-func (l *XORMLogBridge) Error(v ...interface{}) {
+func (l *XORMLogBridge) Error(v ...any) {
 	l.Log(stackLevel, log.ERROR, "%s", fmt.Sprint(v...))
 }
 
 // Errorf show error log
-func (l *XORMLogBridge) Errorf(format string, v ...interface{}) {
+func (l *XORMLogBridge) Errorf(format string, v ...any) {
 	l.Log(stackLevel, log.ERROR, format, v...)
 }
 
 // Info show information level log
-func (l *XORMLogBridge) Info(v ...interface{}) {
+func (l *XORMLogBridge) Info(v ...any) {
 	l.Log(stackLevel, log.INFO, "%s", fmt.Sprint(v...))
 }
 
 // Infof show information level log
-func (l *XORMLogBridge) Infof(format string, v ...interface{}) {
+func (l *XORMLogBridge) Infof(format string, v ...any) {
 	l.Log(stackLevel, log.INFO, format, v...)
 }
 
 // Warn show warning log
-func (l *XORMLogBridge) Warn(v ...interface{}) {
+func (l *XORMLogBridge) Warn(v ...any) {
 	l.Log(stackLevel, log.WARN, "%s", fmt.Sprint(v...))
 }
 
 // Warnf show warnning log
-func (l *XORMLogBridge) Warnf(format string, v ...interface{}) {
+func (l *XORMLogBridge) Warnf(format string, v ...any) {
 	l.Log(stackLevel, log.WARN, format, v...)
 }
 

models/git/branch.go

···
 	// 4. Update all not merged pull request base branch name
 	_, err = sess.Table("pull_request").Where("base_repo_id=? AND base_branch=? AND has_merged=?",
 		repo.ID, from, false).
-		Update(map[string]interface{}{"base_branch": to})
+		Update(map[string]any{"base_branch": to})
 	if err != nil {
 		return err
 	}

models/git/lfs.go

···
 
 	sess := db.GetEngine(ctx)
 
-	oids := make([]interface{}, len(metas))
+	oids := make([]any, len(metas))
 	oidMap := make(map[string]*LFSMetaObject, len(metas))
 	for i, meta := range metas {
 		oids[i] = meta.Oid

models/issues/comment.go

···
 	}
 	if _, err := e.Table("action").
 		Where("comment_id = ?", comment.ID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"is_deleted": true,
 		}); err != nil {
 		return err
···
 				}),
 		)).
 		And("comment.original_author_id = ?", originalAuthorID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"poster_id":          posterID,
 			"original_author":    "",
 			"original_author_id": 0,

models/issues/issue.go

···
 
 	_, err = db.GetEngine(ctx).Table("issue").
 		Where("id = ?", issue.ID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"pin_order": maxPin + 1,
 		})
 	if err != nil {
···
 
 	_, err = db.GetEngine(ctx).Table("issue").
 		Where("id = ?", issue.ID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"pin_order": 0,
 		})
 	if err != nil {
···
 
 	_, err = db.GetEngine(dbctx).Table("issue").
 		Where("id = ?", issue.ID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"pin_order": newPosition,
 		})
 	if err != nil {

models/issues/issue_update.go

···
 }
 
 // DeleteInIssue delete records in beans with external key issue_id = ?
-func DeleteInIssue(ctx context.Context, issueID int64, beans ...interface{}) error {
+func DeleteInIssue(ctx context.Context, issueID int64, beans ...any) error {
 	e := db.GetEngine(ctx)
 	for _, bean := range beans {
 		if _, err := e.In("issue_id", issueID).Delete(bean); err != nil {
···
 	_, err := db.GetEngine(db.DefaultContext).Table("issue").
 		Where("repo_id IN (SELECT id FROM repository WHERE original_service_type = ?)", gitServiceType).
 		And("original_author_id = ?", originalAuthorID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"poster_id":          posterID,
 			"original_author":    "",
 			"original_author_id": 0,
···
 	_, err := db.GetEngine(db.DefaultContext).Table("reaction").
 		Where("original_author_id = ?", originalAuthorID).
 		And(migratedIssueCond(gitServiceType)).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"user_id":            userID,
 			"original_author":    "",
 			"original_author_id": 0,

models/issues/review.go

···
 	_, err := db.GetEngine(db.DefaultContext).Table("review").
 		Where("original_author_id = ?", originalAuthorID).
 		And(migratedIssueCond(tp)).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"reviewer_id":        posterID,
 			"original_author":    "",
 			"original_author_id": 0,

models/migrations/base/db.go

···
 
 // RecreateTables will recreate the tables for the provided beans using the newly provided bean definition and move all data to that new table
 // WARNING: YOU MUST PROVIDE THE FULL BEAN DEFINITION
-func RecreateTables(beans ...interface{}) func(*xorm.Engine) error {
+func RecreateTables(beans ...any) func(*xorm.Engine) error {
 	return func(x *xorm.Engine) error {
 		sess := x.NewSession()
 		defer sess.Close()
···
 // RecreateTable will recreate the table using the newly provided bean definition and move all data to that new table
 // WARNING: YOU MUST PROVIDE THE FULL BEAN DEFINITION
 // WARNING: YOU MUST COMMIT THE SESSION AT THE END
-func RecreateTable(sess *xorm.Session, bean interface{}) error {
+func RecreateTable(sess *xorm.Session, bean any) error {
 	// TODO: This will not work if there are foreign keys
 
 	tableName := sess.Engine().TableName(bean)

models/migrations/base/tests.go

···
 // Provide models to be sync'd with the database - in particular any models you expect fixtures to be loaded from.
 //
 // fixtures in `models/migrations/fixtures/<TestName>` will be loaded automatically
-func PrepareTestEnv(t *testing.T, skip int, syncModels ...interface{}) (*xorm.Engine, func()) {
+func PrepareTestEnv(t *testing.T, skip int, syncModels ...any) (*xorm.Engine, func()) {
 	t.Helper()
 	ourSkip := 2
 	ourSkip += skip

models/migrations/v1_10/v100.go

···
 	}
 
 	type ExternalLoginUser struct {
-		ExternalID        string                 `xorm:"pk NOT NULL"`
-		UserID            int64                  `xorm:"INDEX NOT NULL"`
-		LoginSourceID     int64                  `xorm:"pk NOT NULL"`
-		RawData           map[string]interface{} `xorm:"TEXT JSON"`
-		Provider          string                 `xorm:"index VARCHAR(25)"`
+		ExternalID        string         `xorm:"pk NOT NULL"`
+		UserID            int64          `xorm:"INDEX NOT NULL"`
+		LoginSourceID     int64          `xorm:"pk NOT NULL"`
+		RawData           map[string]any `xorm:"TEXT JSON"`
+		Provider          string         `xorm:"index VARCHAR(25)"`
 		Email             string
 		Name              string
 		FirstName         string

models/migrations/v1_16/v189.go

···
 )
 
 func UnwrapLDAPSourceCfg(x *xorm.Engine) error {
-	jsonUnmarshalHandleDoubleEncode := func(bs []byte, v interface{}) error {
+	jsonUnmarshalHandleDoubleEncode := func(bs []byte, v any) error {
 		err := json.Unmarshal(bs, v)
 		if err != nil {
 			ok := true
···
 	const dldapType = 5
 
 	type WrappedSource struct {
-		Source map[string]interface{}
+		Source map[string]any
 	}
 
 	// change lower_email as unique
···
 
 		for _, source := range sources {
 			wrapped := &WrappedSource{
-				Source: map[string]interface{}{},
+				Source: map[string]any{},
 			}
 			err := jsonUnmarshalHandleDoubleEncode([]byte(source.Cfg), &wrapped)
 			if err != nil {

models/migrations/v1_16/v189_test.go

···
 		}
 
 		for _, source := range sources {
-			converted := map[string]interface{}{}
-			expected := map[string]interface{}{}
+			converted := map[string]any{}
+			expected := map[string]any{}
 
 			if err := json.Unmarshal([]byte(source.Cfg), &converted); err != nil {
 				assert.NoError(t, err)

models/migrations/v1_19/v233_test.go

···
 		return
 	}
 	for _, h := range hookTasks {
-		var m map[string]interface{}
+		var m map[string]any
 		err := json.Unmarshal([]byte(h.PayloadContent), &m)
 		assert.NoError(t, err)
 		assert.Nil(t, m["access_token"])

models/migrations/v1_6/v70.go

···
 	// RepoUnit describes all units of a repository
 	type RepoUnit struct {
 		ID          int64
-		RepoID      int64                  `xorm:"INDEX(s)"`
-		Type        int                    `xorm:"INDEX(s)"`
-		Config      map[string]interface{} `xorm:"JSON"`
-		CreatedUnix int64                  `xorm:"INDEX CREATED"`
-		Created     time.Time              `xorm:"-"`
+		RepoID      int64          `xorm:"INDEX(s)"`
+		Type        int            `xorm:"INDEX(s)"`
+		Config      map[string]any `xorm:"JSON"`
+		CreatedUnix int64          `xorm:"INDEX CREATED"`
+		Created     time.Time      `xorm:"-"`
 	}
 
 	// Updating existing issue units
···
 	}
 	for _, unit := range units {
 		if unit.Config == nil {
-			unit.Config = make(map[string]interface{})
+			unit.Config = make(map[string]any)
 		}
 		if _, ok := unit.Config["EnableDependencies"]; !ok {
 			unit.Config["EnableDependencies"] = setting.Service.DefaultEnableDependencies

models/migrations/v1_8/v76.go

···
 	// RepoUnit describes all units of a repository
 	type RepoUnit struct {
 		ID          int64
-		RepoID      int64                  `xorm:"INDEX(s)"`
-		Type        int                    `xorm:"INDEX(s)"`
-		Config      map[string]interface{} `xorm:"JSON"`
-		CreatedUnix timeutil.TimeStamp     `xorm:"INDEX CREATED"`
+		RepoID      int64              `xorm:"INDEX(s)"`
+		Type        int                `xorm:"INDEX(s)"`
+		Config      map[string]any     `xorm:"JSON"`
+		CreatedUnix timeutil.TimeStamp `xorm:"INDEX CREATED"`
 	}
 
 	const (
···
 	}
 	for _, unit := range units {
 		if unit.Config == nil {
-			unit.Config = make(map[string]interface{})
+			unit.Config = make(map[string]any)
 		}
 		// Allow the new merge style if all other merge styles are allowed
 		allowMergeRebase := true

models/packages/descriptor.go

···
 	Creator           *user_model.User
 	PackageProperties PackagePropertyList
 	VersionProperties PackagePropertyList
-	Metadata          interface{}
+	Metadata          any
 	Files             []*PackageFileDescriptor
 }
 
···
 		return nil, err
 	}
 
-	var metadata interface{}
+	var metadata any
 	switch p.Type {
 	case TypeAlpine:
 		metadata = &alpine.VersionMetadata{}

models/repo.go

···
 	return repo_model.UpdateRepoIssueNumbers(ctx, id, true, true)
 }
 
-func statsQuery(args ...interface{}) func(context.Context) ([]map[string][]byte, error) {
+func statsQuery(args ...any) func(context.Context) ([]map[string][]byte, error) {
 	return func(ctx context.Context) ([]map[string][]byte, error) {
 		return db.GetEngine(ctx).Query(args...)
 	}

models/repo/mirror.go

···
 }
 
 // MirrorsIterate iterates all mirror repositories.
-func MirrorsIterate(limit int, f func(idx int, bean interface{}) error) error {
+func MirrorsIterate(limit int, f func(idx int, bean any) error) error {
 	sess := db.GetEngine(db.DefaultContext).
 		Where("next_update_unix<=?", time.Now().Unix()).
 		And("next_update_unix!=0").

models/repo/pushmirror.go

···
 }
 
 // PushMirrorsIterate iterates all push-mirror repositories.
-func PushMirrorsIterate(ctx context.Context, limit int, f func(idx int, bean interface{}) error) error {
+func PushMirrorsIterate(ctx context.Context, limit int, f func(idx int, bean any) error) error {
 	sess := db.GetEngine(ctx).
 		Where("last_update + (`interval` / ?) <= ?", time.Second, time.Now().Unix()).
 		And("`interval` != 0").

models/repo/pushmirror_test.go

···
 
 	time.Sleep(1 * time.Millisecond)
 
-	repo_model.PushMirrorsIterate(db.DefaultContext, 1, func(idx int, bean interface{}) error {
+	repo_model.PushMirrorsIterate(db.DefaultContext, 1, func(idx int, bean any) error {
 		m, ok := bean.(*repo_model.PushMirror)
 		assert.True(t, ok)
 		assert.Equal(t, "test-1", m.RemoteName)

models/repo/release.go

···
 	_, err := db.GetEngine(db.DefaultContext).Table("release").
 		Where("repo_id IN (SELECT id FROM repository WHERE original_service_type = ?)", gitServiceType).
 		And("original_author_id = ?", originalAuthorID).
-		Update(map[string]interface{}{
+		Update(map[string]any{
 			"publisher_id":       posterID,
 			"original_author":    "",
 			"original_author_id": 0,

models/repo/repo_list.go

···
 		opts.OrderBy = db.SearchOrderByAlphabetically
 	}
 
-	args := make([]interface{}, 0)
+	args := make([]any, 0)
 	if opts.PriorityOwnerID > 0 {
 		opts.OrderBy = db.SearchOrderBy(fmt.Sprintf("CASE WHEN owner_id = ? THEN 0 ELSE owner_id END, %s", opts.OrderBy))
 		args = append(args, opts.PriorityOwnerID)

models/system/notice.go

···
 }
 
 // CreateNotice creates new system notice.
-func CreateNotice(ctx context.Context, tp NoticeType, desc string, args ...interface{}) error {
+func CreateNotice(ctx context.Context, tp NoticeType, desc string, args ...any) error {
 	if len(args) > 0 {
 		desc = fmt.Sprintf(desc, args...)
 	}
···
 }
 
 // CreateRepositoryNotice creates new system notice with type NoticeRepository.
-func CreateRepositoryNotice(desc string, args ...interface{}) error {
+func CreateRepositoryNotice(desc string, args ...any) error {
 	// Note we use the db.DefaultContext here rather than passing in a context as the context may be cancelled
 	return CreateNotice(db.DefaultContext, NoticeRepository, desc, args...)
 }

models/unittest/consistency.go

···
 	modelsCommentTypeComment   = 0
 )
 
-var consistencyCheckMap = make(map[string]func(t assert.TestingT, bean interface{}))
+var consistencyCheckMap = make(map[string]func(t assert.TestingT, bean any))
 
 // CheckConsistencyFor test that all matching database entries are consistent
-func CheckConsistencyFor(t assert.TestingT, beansToCheck ...interface{}) {
+func CheckConsistencyFor(t assert.TestingT, beansToCheck ...any) {
 	for _, bean := range beansToCheck {
 		sliceType := reflect.SliceOf(reflect.TypeOf(bean))
 		sliceValue := reflect.MakeSlice(sliceType, 0, 10)
···
 	}
 }
 
-func checkForConsistency(t assert.TestingT, bean interface{}) {
+func checkForConsistency(t assert.TestingT, bean any) {
 	tb, err := db.TableInfo(bean)
 	assert.NoError(t, err)
 	f := consistencyCheckMap[tb.Name]
···
 		return i
 	}
 
-	checkForUserConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForUserConsistency := func(t assert.TestingT, bean any) {
 		user := reflectionWrap(bean)
 		AssertCountByCond(t, "repository", builder.Eq{"owner_id": user.int("ID")}, user.int("NumRepos"))
 		AssertCountByCond(t, "star", builder.Eq{"uid": user.int("ID")}, user.int("NumStars"))
···
 		}
 	}
 
-	checkForRepoConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForRepoConsistency := func(t assert.TestingT, bean any) {
 		repo := reflectionWrap(bean)
 		assert.Equal(t, repo.str("LowerName"), strings.ToLower(repo.str("Name")), "repo: %+v", repo)
 		AssertCountByCond(t, "star", builder.Eq{"repo_id": repo.int("ID")}, repo.int("NumStars"))
···
 			"Unexpected number of closed milestones for repo id: %d", repo.int("ID"))
 	}
 
-	checkForIssueConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForIssueConsistency := func(t assert.TestingT, bean any) {
 		issue := reflectionWrap(bean)
 		typeComment := modelsCommentTypeComment
 		actual := GetCountByCond(t, "comment", builder.Eq{"`type`": typeComment, "issue_id": issue.int("ID")})
···
 		}
 	}
 
-	checkForPullRequestConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForPullRequestConsistency := func(t assert.TestingT, bean any) {
 		pr := reflectionWrap(bean)
 		issueRow := AssertExistsAndLoadMap(t, "issue", builder.Eq{"id": pr.int("IssueID")})
 		assert.True(t, parseBool(issueRow["is_pull"]))
 		assert.EqualValues(t, parseInt(issueRow["index"]), pr.int("Index"), "Unexpected index for pull request id: %d", pr.int("ID"))
 	}
 
-	checkForMilestoneConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForMilestoneConsistency := func(t assert.TestingT, bean any) {
 		milestone := reflectionWrap(bean)
 		AssertCountByCond(t, "issue", builder.Eq{"milestone_id": milestone.int("ID")}, milestone.int("NumIssues"))
 
···
 		assert.Equal(t, completeness, milestone.int("Completeness"))
 	}
 
-	checkForLabelConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForLabelConsistency := func(t assert.TestingT, bean any) {
 		label := reflectionWrap(bean)
 		issueLabels, err := db.GetEngine(db.DefaultContext).Table("issue_label").
 			Where(builder.Eq{"label_id": label.int("ID")}).
···
 		assert.EqualValues(t, expected, label.int("NumClosedIssues"), "Unexpected number of closed issues for label id: %d", label.int("ID"))
 	}
 
-	checkForTeamConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForTeamConsistency := func(t assert.TestingT, bean any) {
 		team := reflectionWrap(bean)
 		AssertCountByCond(t, "team_user", builder.Eq{"team_id": team.int("ID")}, team.int("NumMembers"))
 		AssertCountByCond(t, "team_repo", builder.Eq{"team_id": team.int("ID")}, team.int("NumRepos"))
 	}
 
-	checkForActionConsistency := func(t assert.TestingT, bean interface{}) {
+	checkForActionConsistency := func(t assert.TestingT, bean any) {
 		action := reflectionWrap(bean)
 		if action.int("RepoID") != 1700 { // dangling intentional
 			repoRow := AssertExistsAndLoadMap(t, "repository", builder.Eq{"id": action.int("RepoID")})

models/unittest/reflection.go

···
 	v reflect.Value
 }
 
-func reflectionWrap(v interface{}) *reflectionValue {
+func reflectionWrap(v any) *reflectionValue {
 	return &reflectionValue{v: reflect.ValueOf(v)}
 }
 

models/unittest/testdb.go

···
 	return fixturesDir
 }
 
-func fatalTestError(fmtStr string, args ...interface{}) {
+func fatalTestError(fmtStr string, args ...any) {
 	_, _ = fmt.Fprintf(os.Stderr, fmtStr, args...)
 	os.Exit(1)
 }

models/user/external_login_user.go

···
 
 // ExternalLoginUser makes the connecting between some existing user and additional external login sources
 type ExternalLoginUser struct {
-	ExternalID        string                 `xorm:"pk NOT NULL"`
-	UserID            int64                  `xorm:"INDEX NOT NULL"`
-	LoginSourceID     int64                  `xorm:"pk NOT NULL"`
-	RawData           map[string]interface{} `xorm:"TEXT JSON"`
-	Provider          string                 `xorm:"index VARCHAR(25)"`
+	ExternalID        string         `xorm:"pk NOT NULL"`
+	UserID            int64          `xorm:"INDEX NOT NULL"`
+	LoginSourceID     int64          `xorm:"pk NOT NULL"`
+	RawData           map[string]any `xorm:"TEXT JSON"`
+	Provider          string         `xorm:"index VARCHAR(25)"`
 	Email             string
 	Name              string
 	FirstName         string

models/webhook/hooktask.go

···
 	}
 }
 
-func (t *HookTask) simpleMarshalJSON(v interface{}) string {
+func (t *HookTask) simpleMarshalJSON(v any) string {
 	p, err := json.Marshal(v)
 	if err != nil {
 		log.Error("Marshal [%d]: %v", t.ID, err)

modules/actions/workflows.go

···
 }
 
 func init() {
-	model.OnDecodeNodeError = func(node yaml.Node, out interface{}, err error) {
+	model.OnDecodeNodeError = func(node yaml.Node, out any, err error) {
 		// Log the error instead of panic or fatal.
 		// It will be a big job to refactor act/pkg/model to return decode error,
 		// so we just log the error and return empty value, and improve it later.

modules/base/tool.go

···
 
 // CreateTimeLimitCode create a time limit code
 // code format: 12 length date time string + 6 minutes string + 40 sha1 encoded string
-func CreateTimeLimitCode(data string, minutes int, startInf interface{}) string {
+func CreateTimeLimitCode(data string, minutes int, startInf any) string {
 	format := "200601021504"
 
 	var start, end time.Time
···
 }
 
 // FormatNumberSI format a number
-func FormatNumberSI(data interface{}) string {
+func FormatNumberSI(data any) string {
 	var num int64
 	if num1, ok := data.(int64); ok {
 		num = num1

modules/cache/cache_redis.go

···
 }
 
 // toStr convert string/int/int64 interface to string. it's only used by the RedisCacher.Put internally
-func toStr(v interface{}) string {
+func toStr(v any) string {
 	if v == nil {
 		return ""
 	}
···
 
 // Put puts value (string type) into cache with key and expire time.
 // If expired is 0, it lives forever.
-func (c *RedisCacher) Put(key string, val interface{}, expire int64) error {
+func (c *RedisCacher) Put(key string, val any, expire int64) error {
 	// this function is not well-designed, it only puts string values into cache
 	key = c.prefix + key
 	if expire == 0 {
···
 }
 
 // Get gets cached value by given key.
-func (c *RedisCacher) Get(key string) interface{} {
+func (c *RedisCacher) Get(key string) any {
 	val, err := c.c.Get(graceful.GetManager().HammerContext(), c.prefix+key).Result()
 	if err != nil {
 		return nil

modules/cache/cache_twoqueue.go

···
 
 // MemoryItem represents a memory cache item.
 type MemoryItem struct {
-	Val     interface{}
+	Val     any
 	Created int64
 	Timeout int64
 }
···
 var _ mc.Cache = &TwoQueueCache{}
 
 // Put puts value into cache with key and expire time.
-func (c *TwoQueueCache) Put(key string, val interface{}, timeout int64) error {
+func (c *TwoQueueCache) Put(key string, val any, timeout int64) error {
 	item := &MemoryItem{
 		Val:     val,
 		Created: time.Now().Unix(),
···
 }
 
 // Get gets cached value by given key.
-func (c *TwoQueueCache) Get(key string) interface{} {
+func (c *TwoQueueCache) Get(key string) any {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	cached, ok := c.cache.Get(key)
···
 	return nil
 }
 
-func (c *TwoQueueCache) checkAndInvalidate(key interface{}) {
+func (c *TwoQueueCache) checkAndInvalidate(key any) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	cached, ok := c.cache.Peek(key)

modules/charset/ambiguous/generate.go

···
 	sort.Slice(tables, func(i, j int) bool {
 		return tables[i].Locale < tables[j].Locale
 	})
-	data := map[string]interface{}{
+	data := map[string]any{
 		"Tables": tables,
 	}
 
···
 	}
 }
 
-func runTemplate(t *template.Template, filename string, data interface{}) error {
+func runTemplate(t *template.Template, filename string, data any) error {
 	buf := bytes.NewBuffer(nil)
 	if err := t.Execute(buf, data); err != nil {
 		return fmt.Errorf("unable to execute template: %w", err)
···
 
 `))
 
-func logf(format string, args ...interface{}) {
+func logf(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, format+"\n", args...)
 }
 
-func verbosef(format string, args ...interface{}) {
+func verbosef(format string, args ...any) {
 	if verbose {
 		logf(format, args...)
 	}
 }
 
-func fatalf(format string, args ...interface{}) {
+func fatalf(format string, args ...any) {
 	logf("fatal: "+format+"\n", args...)
 	os.Exit(1)
 }

modules/charset/invisible/generate.go

···
 	}
 }
 
-func runTemplate(t *template.Template, filename string, data interface{}) error {
+func runTemplate(t *template.Template, filename string, data any) error {
 	buf := bytes.NewBuffer(nil)
 	if err := t.Execute(buf, data); err != nil {
 		return fmt.Errorf("unable to execute template: %w", err)
···
 }
 `))
 
-func logf(format string, args ...interface{}) {
+func logf(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, format+"\n", args...)
 }
 
-func verbosef(format string, args ...interface{}) {
+func verbosef(format string, args ...any) {
 	if verbose {
 		logf(format, args...)
 	}
 }
 
-func fatalf(format string, args ...interface{}) {
+func fatalf(format string, args ...any) {
 	logf("fatal: "+format+"\n", args...)
 	os.Exit(1)
 }

modules/context/access_log.go

···
 	Identity       *string
 	Start          *time.Time
 	ResponseWriter http.ResponseWriter
-	Ctx            map[string]interface{}
+	Ctx            map[string]any
 	RequestID      *string
 }
 
···
 				Identity:       &identity,
 				Start:          &start,
 				ResponseWriter: rw,
-				Ctx: map[string]interface{}{
+				Ctx: map[string]any{
 					"RemoteAddr": req.RemoteAddr,
 					"RemoteHost": reqHost,
 					"Req":        req,

modules/context/api.go

···
 
 // Error responds with an error message to client with given obj as the message.
 // If status is 500, also it prints error to log.
-func (ctx *APIContext) Error(status int, title string, obj interface{}) {
+func (ctx *APIContext) Error(status int, title string, obj any) {
 	var message string
 	if err, ok := obj.(error); ok {
 		message = err.Error()
···
 
 // NotFound handles 404s for APIContext
 // String will replace message, errors will be added to a slice
-func (ctx *APIContext) NotFound(objs ...interface{}) {
+func (ctx *APIContext) NotFound(objs ...any) {
 	message := ctx.Tr("error.not_found")
 	var errors []string
 	for _, obj := range objs {
···
 		}
 	}
 
-	ctx.JSON(http.StatusNotFound, map[string]interface{}{
+	ctx.JSON(http.StatusNotFound, map[string]any{
 		"message": message,
 		"url":     setting.API.SwaggerURL,
 		"errors":  errors,

modules/context/base.go

···
 }
 
 // JSON render content as JSON
-func (b *Base) JSON(status int, content interface{}) {
+func (b *Base) JSON(status int, content any) {
 	b.Resp.Header().Set("Content-Type", "application/json;charset=utf-8")
 	b.Resp.WriteHeader(status)
 	if err := json.NewEncoder(b.Resp).Encode(content); err != nil {

modules/context/captcha.go

···
 
 // VerifyCaptcha verifies Captcha data
 // No-op if captchas are not enabled
-func VerifyCaptcha(ctx *Context, tpl base.TplName, form interface{}) {
+func VerifyCaptcha(ctx *Context, tpl base.TplName, form any) {
 	if !setting.Service.EnableCaptcha {
 		return
 	}

modules/context/context.go

···
 // Render represents a template render
 type Render interface {
 	TemplateLookup(tmpl string) (templates.TemplateExecutor, error)
-	HTML(w io.Writer, status int, name string, data interface{}) error
+	HTML(w io.Writer, status int, name string, data any) error
 }
 
 // Context represents context of a request.
···
 // TrHTMLEscapeArgs runs ".Locale.Tr()" but pre-escapes all arguments with html.EscapeString.
 // This is useful if the locale message is intended to only produce HTML content.
 func (ctx *Context) TrHTMLEscapeArgs(msg string, args ...string) string {
-	trArgs := make([]interface{}, len(args))
+	trArgs := make([]any, len(args))
 	for i, arg := range args {
 		trArgs[i] = html.EscapeString(arg)
 	}

modules/context/context_response.go

···
 }
 
 // RenderToString renders the template content to a string
-func (ctx *Context) RenderToString(name base.TplName, data map[string]interface{}) (string, error) {
+func (ctx *Context) RenderToString(name base.TplName, data map[string]any) (string, error) {
 	var buf strings.Builder
 	err := ctx.Render.HTML(&buf, http.StatusOK, string(name), data)
 	return buf.String(), err
 }
 
 // RenderWithErr used for page has form validation but need to prompt error to users.
-func (ctx *Context) RenderWithErr(msg string, tpl base.TplName, form interface{}) {
+func (ctx *Context) RenderWithErr(msg string, tpl base.TplName, form any) {
 	if form != nil {
 		middleware.AssignForm(form, ctx.Data)
 	}

modules/context/package.go

···
 // PackageAssignment returns a middleware to handle Context.Package assignment
 func PackageAssignment() func(ctx *Context) {
 	return func(ctx *Context) {
-		errorFn := func(status int, title string, obj interface{}) {
+		errorFn := func(status int, title string, obj any) {
 			err, ok := obj.(error)
 			if !ok {
 				err = fmt.Errorf("%s", obj)
···
 	}
 }
 
-func packageAssignment(ctx *packageAssignmentCtx, errCb func(int, string, interface{})) *Package {
+func packageAssignment(ctx *packageAssignmentCtx, errCb func(int, string, any)) *Package {
 	pkg := &Package{
 		Owner: ctx.ContextUser,
 	}

modules/context/pagination.go

···
 	if !exists {
 		return
 	}
-	paramData := fmt.Sprintf("%v", ctx.Data[ctxKey]) // cast interface{} to string
+	paramData := fmt.Sprintf("%v", ctx.Data[ctxKey]) // cast any to string
 	urlParam := fmt.Sprintf("%s=%v", url.QueryEscape(paramKey), url.QueryEscape(paramData))
 	p.urlParams = append(p.urlParams, urlParam)
 }

modules/context/permission.go

···
 		}
 		if log.IsTrace() {
 			var format string
-			var args []interface{}
+			var args []any
 			if ctx.IsSigned {
 				format = "Permission Denied: User %-v cannot read ["
 				args = append(args, ctx.Doer)

modules/context/private.go

···
 	return ctx.Base.Err()
 }
 
-var privateContextKey interface{} = "default_private_context"
+var privateContextKey any = "default_private_context"
 
 // GetPrivateContext returns a context for Private routes
 func GetPrivateContext(req *http.Request) *PrivateContext {

modules/eventsource/event.go

···
 type Event struct {
 	// Name represents the value of the event: tag in the stream
 	Name string
-	// Data is either JSONified []byte or interface{} that can be JSONd
-	Data interface{}
+	// Data is either JSONified []byte or any that can be JSONd
+	Data any
 	// ID represents the ID of an event
 	ID string
 	// Retry tells the receiver only to attempt to reconnect to the source after this time

modules/git/commit_info_gogit.go

···
 	refSha := c.ID().String()
 
 	// We do a tree traversal with nodes sorted by commit time
-	heap := binaryheap.NewWith(func(a, b interface{}) int {
+	heap := binaryheap.NewWith(func(a, b any) int {
 		if a.(*commitAndPaths).commit.CommitTime().Before(b.(*commitAndPaths).commit.CommitTime()) {
 			return 1
 		}

modules/git/foreachref/parser_test.go

···
 	}
 }
 
-func pretty(v interface{}) string {
+func pretty(v any) string {
 	data, err := json.MarshalIndent(v, "", "  ")
 	if err != nil {
 		// shouldn't happen

modules/git/git.go

···
 		return "(git not found)"
 	}
 	format := "%s"
-	args := []interface{}{gitVersion.Original()}
+	args := []any{gitVersion.Original()}
 	// Since git wire protocol has been released from git v2.18
 	if setting.Git.EnableAutoGitWireProtocol && CheckGitVersionAtLeast("2.18") == nil {
 		format += ", Wire Protocol %s Enabled"

modules/git/last_commit_cache.go

···
 // Cache represents a caching interface
 type Cache interface {
 	// Put puts value into cache with key and expire time.
-	Put(key string, val interface{}, timeout int64) error
+	Put(key string, val any, timeout int64) error
 	// Get gets cached value by given key.
-	Get(key string) interface{}
+	Get(key string) any
 }
 
 func getCacheKey(repoPath, commitID, entryPath string) string {

modules/git/utils.go

···
 // ObjectCache provides thread-safe cache operations.
 type ObjectCache struct {
 	lock  sync.RWMutex
-	cache map[string]interface{}
+	cache map[string]any
 }
 
 func newObjectCache() *ObjectCache {
 	return &ObjectCache{
-		cache: make(map[string]interface{}, 10),
+		cache: make(map[string]any, 10),
 	}
 }
 
 // Set add obj to cache
-func (oc *ObjectCache) Set(id string, obj interface{}) {
+func (oc *ObjectCache) Set(id string, obj any) {
 	oc.lock.Lock()
 	defer oc.lock.Unlock()
 
···
 }
 
 // Get get cached obj by id
-func (oc *ObjectCache) Get(id string) (interface{}, bool) {
+func (oc *ObjectCache) Get(id string) (any, bool) {
 	oc.lock.RLock()
 	defer oc.lock.RUnlock()
 

modules/graceful/manager.go

···
 }
 
 // Value allows the manager to be viewed as a context.Context done at Terminate
-func (g *Manager) Value(key interface{}) interface{} {
+func (g *Manager) Value(key any) any {
 	return g.managerCtx.Value(key)
 }
 

modules/html/html.go

···
 
 // ParseSizeAndClass get size and class from string with default values
 // If present, "others" expects the new size first and then the classes to use
-func ParseSizeAndClass(defaultSize int, defaultClass string, others ...interface{}) (int, string) {
+func ParseSizeAndClass(defaultSize int, defaultClass string, others ...any) (int, string) {
 	if len(others) == 0 {
 		return defaultSize, defaultClass
 	}

modules/httplib/request.go

···
 
 // Body adds request raw body.
 // it supports string and []byte.
-func (r *Request) Body(data interface{}) *Request {
+func (r *Request) Body(data any) *Request {
 	switch t := data.(type) {
 	case string:
 		bf := bytes.NewBufferString(t)

modules/indexer/code/bleve/bleve.go

···
 }
 
 func addUnicodeNormalizeTokenFilter(m *mapping.IndexMappingImpl) error {
-	return m.AddCustomTokenFilter(unicodeNormalizeName, map[string]interface{}{
+	return m.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{
 		"type": unicodenorm.Name,
 		"form": unicodenorm.NFC,
 	})
···
 	mapping := bleve.NewIndexMapping()
 	if err := addUnicodeNormalizeTokenFilter(mapping); err != nil {
 		return nil, err
-	} else if err := mapping.AddCustomAnalyzer(repoIndexerAnalyzer, map[string]interface{}{
+	} else if err := mapping.AddCustomAnalyzer(repoIndexerAnalyzer, map[string]any{
 		"type":          analyzer_custom.Name,
 		"char_filters":  []string{},
 		"tokenizer":     unicode.Name,

modules/indexer/code/elasticsearch/elasticsearch.go

···
 		elastic.NewBulkIndexRequest().
 			Index(b.inner.VersionedIndexName()).
 			Id(id).
-			Doc(map[string]interface{}{
+			Doc(map[string]any{
 				"repo_id":    repo.ID,
 				"content":    string(charset.ToUTF8DropErrors(fileContents)),
 				"commit_id":  sha,
···
 		}
 
 		repoID, fileName := internal.ParseIndexerID(hit.Id)
-		res := make(map[string]interface{})
+		res := make(map[string]any)
 		if err := json.Unmarshal(hit.Source, &res); err != nil {
 			return 0, nil, nil, err
 		}
···
 	query := elastic.NewBoolQuery()
 	query = query.Must(kwQuery)
 	if len(repoIDs) > 0 {
-		repoStrs := make([]interface{}, 0, len(repoIDs))
+		repoStrs := make([]any, 0, len(repoIDs))
 		for _, repoID := range repoIDs {
 			repoStrs = append(repoStrs, repoID)
 		}

modules/indexer/internal/bleve/batch.go

···
 }
 
 // Index add a new index to batch
-func (b *FlushingBatch) Index(id string, data interface{}) error {
+func (b *FlushingBatch) Index(id string, data any) error {
 	if err := b.batch.Index(id, data); err != nil {
 		return err
 	}

modules/indexer/issues/bleve/bleve.go

···
 const unicodeNormalizeName = "unicodeNormalize"
 
 func addUnicodeNormalizeTokenFilter(m *mapping.IndexMappingImpl) error {
-	return m.AddCustomTokenFilter(unicodeNormalizeName, map[string]interface{}{
+	return m.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{
 		"type": unicodenorm.Name,
 		"form": unicodenorm.NFC,
 	})
···
 
 	if err := addUnicodeNormalizeTokenFilter(mapping); err != nil {
 		return nil, err
-	} else if err = mapping.AddCustomAnalyzer(issueIndexerAnalyzer, map[string]interface{}{
+	} else if err = mapping.AddCustomAnalyzer(issueIndexerAnalyzer, map[string]any{
 		"type":          custom.Name,
 		"char_filters":  []string{},
 		"tokenizer":     unicode.Name,

modules/indexer/issues/elasticsearch/elasticsearch.go

···
 		_, err := b.inner.Client.Index().
 			Index(b.inner.VersionedIndexName()).
 			Id(fmt.Sprintf("%d", issue.ID)).
-			BodyJson(map[string]interface{}{
+			BodyJson(map[string]any{
 				"id":       issue.ID,
 				"repo_id":  issue.RepoID,
 				"title":    issue.Title,
···
 			elastic.NewBulkIndexRequest().
 				Index(b.inner.VersionedIndexName()).
 				Id(fmt.Sprintf("%d", issue.ID)).
-				Doc(map[string]interface{}{
+				Doc(map[string]any{
 					"id":       issue.ID,
 					"repo_id":  issue.RepoID,
 					"title":    issue.Title,
···
 	query := elastic.NewBoolQuery()
 	query = query.Must(kwQuery)
 	if len(repoIDs) > 0 {
-		repoStrs := make([]interface{}, 0, len(repoIDs))
+		repoStrs := make([]any, 0, len(repoIDs))
 		for _, repoID := range repoIDs {
 			repoStrs = append(repoStrs, repoID)
 		}

modules/indexer/issues/meilisearch/meilisearch.go

···
 	hits := make([]internal.Match, 0, len(searchRes.Hits))
 	for _, hit := range searchRes.Hits {
 		hits = append(hits, internal.Match{
-			ID: int64(hit.(map[string]interface{})["id"].(float64)),
+			ID: int64(hit.(map[string]any)["id"].(float64)),
 		})
 	}
 	return &internal.SearchResult{

modules/issue/template/template.go

···
 	}
 	position := newErrorPosition(idx, field.Type)
 
-	options, ok := field.Attributes["options"].([]interface{})
+	options, ok := field.Attributes["options"].([]any)
 	if !ok || len(options) == 0 {
 		return position.Errorf("'options' is required and should be a array")
 	}
···
 				return position.Errorf("should be a string")
 			}
 		case api.IssueFormFieldTypeCheckboxes:
-			opt, ok := option.(map[string]interface{})
+			opt, ok := option.(map[string]any)
 			if !ok {
 				return position.Errorf("should be a dictionary")
 			}
···
 	return nil
 }
 
-func validateStringItem(position errorPosition, m map[string]interface{}, required bool, names ...string) error {
+func validateStringItem(position errorPosition, m map[string]any, required bool, names ...string) error {
 	for _, name := range names {
 		v, ok := m[name]
 		if !ok {
···
 	return nil
 }
 
-func validateBoolItem(position errorPosition, m map[string]interface{}, names ...string) error {
+func validateBoolItem(position errorPosition, m map[string]any, names ...string) error {
 	for _, name := range names {
 		v, ok := m[name]
 		if !ok {
···
 
 type errorPosition string
 
-func (p errorPosition) Errorf(format string, a ...interface{}) error {
+func (p errorPosition) Errorf(format string, a ...any) error {
 	return fmt.Errorf(string(p)+": "+format, a...)
 }
 
···
 }
 
 func (f *valuedField) Options() []*valuedOption {
-	if options, ok := f.Attributes["options"].([]interface{}); ok {
+	if options, ok := f.Attributes["options"].([]any); ok {
 		ret := make([]*valuedOption, 0, len(options))
 		for i, option := range options {
 			ret = append(ret, &valuedOption{
···
 
 type valuedOption struct {
 	index int
-	data  interface{}
+	data  any
 	field *valuedField
 }
 
···
 			return label
 		}
 	case api.IssueFormFieldTypeCheckboxes:
-		if vs, ok := o.data.(map[string]interface{}); ok {
+		if vs, ok := o.data.(map[string]any); ok {
 			if v, ok := vs["label"].(string); ok {
 				return v
 			}

modules/issue/template/template_test.go

···
 					{
 						Type: "markdown",
 						ID:   "id1",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"value": "Value of the markdown",
 						},
 					},
 					{
 						Type: "textarea",
 						ID:   "id2",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"label":       "Label of textarea",
 							"description": "Description of textarea",
 							"placeholder": "Placeholder of textarea",
 							"value":       "Value of textarea",
 							"render":      "bash",
 						},
-						Validations: map[string]interface{}{
+						Validations: map[string]any{
 							"required": true,
 						},
 					},
 					{
 						Type: "input",
 						ID:   "id3",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"label":       "Label of input",
 							"description": "Description of input",
 							"placeholder": "Placeholder of input",
 							"value":       "Value of input",
 						},
-						Validations: map[string]interface{}{
+						Validations: map[string]any{
 							"required":  true,
 							"is_number": true,
 							"regex":     "[a-zA-Z0-9]+",
···
 					{
 						Type: "dropdown",
 						ID:   "id4",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"label":       "Label of dropdown",
 							"description": "Description of dropdown",
 							"multiple":    true,
-							"options": []interface{}{
+							"options": []any{
 								"Option 1 of dropdown",
 								"Option 2 of dropdown",
 								"Option 3 of dropdown",
 							},
 						},
-						Validations: map[string]interface{}{
+						Validations: map[string]any{
 							"required": true,
 						},
 					},
 					{
 						Type: "checkboxes",
 						ID:   "id5",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"label":       "Label of checkboxes",
 							"description": "Description of checkboxes",
-							"options": []interface{}{
-								map[string]interface{}{"label": "Option 1 of checkboxes", "required": true},
-								map[string]interface{}{"label": "Option 2 of checkboxes", "required": false},
-								map[string]interface{}{"label": "Option 3 of checkboxes", "required": true},
+							"options": []any{
+								map[string]any{"label": "Option 1 of checkboxes", "required": true},
+								map[string]any{"label": "Option 2 of checkboxes", "required": false},
+								map[string]any{"label": "Option 3 of checkboxes", "required": true},
 							},
 						},
 					},
···
 					{
 						Type: "markdown",
 						ID:   "id1",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"value": "Value of the markdown",
 						},
 					},
···
 					{
 						Type: "markdown",
 						ID:   "id1",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"value": "Value of the markdown",
 						},
 					},
···
 					{
 						Type: "markdown",
 						ID:   "id1",
-						Attributes: map[string]interface{}{
+						Attributes: map[string]any{
 							"value": "Value of the markdown",
 						},
 					},

modules/json/json.go

···
 
 // Encoder represents an encoder for json
 type Encoder interface {
-	Encode(v interface{}) error
+	Encode(v any) error
 }
 
 // Decoder represents a decoder for json
 type Decoder interface {
-	Decode(v interface{}) error
+	Decode(v any) error
 }
 
 // Interface represents an interface to handle json data
 type Interface interface {
-	Marshal(v interface{}) ([]byte, error)
-	Unmarshal(data []byte, v interface{}) error
+	Marshal(v any) ([]byte, error)
+	Unmarshal(data []byte, v any) error
 	NewEncoder(writer io.Writer) Encoder
 	NewDecoder(reader io.Reader) Decoder
 	Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error
···
 type StdJSON struct{}
 
 // Marshal implements Interface
-func (StdJSON) Marshal(v interface{}) ([]byte, error) {
+func (StdJSON) Marshal(v any) ([]byte, error) {
 	return json.Marshal(v)
 }
 
 // Unmarshal implements Interface
-func (StdJSON) Unmarshal(data []byte, v interface{}) error {
+func (StdJSON) Unmarshal(data []byte, v any) error {
 	return json.Unmarshal(data, v)
 }
 
···
 }
 
 // Marshal implements Interface
-func (j JSONiter) Marshal(v interface{}) ([]byte, error) {
+func (j JSONiter) Marshal(v any) ([]byte, error) {
 	return j.API.Marshal(v)
 }
 
 // Unmarshal implements Interface
-func (j JSONiter) Unmarshal(data []byte, v interface{}) error {
+func (j JSONiter) Unmarshal(data []byte, v any) error {
 	return j.API.Unmarshal(data, v)
 }
 
···
 }
 
 // Marshal converts object as bytes
-func Marshal(v interface{}) ([]byte, error) {
+func Marshal(v any) ([]byte, error) {
 	return DefaultJSONHandler.Marshal(v)
 }
 
 // Unmarshal decodes object from bytes
-func Unmarshal(data []byte, v interface{}) error {
+func Unmarshal(data []byte, v any) error {
 	return DefaultJSONHandler.Unmarshal(data, v)
 }
 
···
 }
 
 // MarshalIndent copied from encoding/json
-func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
 	b, err := Marshal(v)
 	if err != nil {
 		return nil, err
···
 
 // UnmarshalHandleDoubleEncode - due to a bug in xorm (see https://gitea.com/xorm/xorm/pulls/1957) - it's
 // possible that a Blob may be double encoded or gain an unwanted prefix of 0xff 0xfe.
-func UnmarshalHandleDoubleEncode(bs []byte, v interface{}) error {
+func UnmarshalHandleDoubleEncode(bs []byte, v any) error {
 	err := json.Unmarshal(bs, v)
 	if err != nil {
 		ok := true

modules/markup/html_internal_test.go

···
 			isExternal = true
 		}
 
-		links := make([]interface{}, len(indices))
+		links := make([]any, len(indices))
 		for i, index := range indices {
 			links[i] = numericIssueLink(util.URLJoin(TestRepoURL, path), "ref-issue", index, marker)
 		}
···
 
 	// alphanumeric: render inputs with valid mentions
 	test := func(s, expectedFmt string, names ...string) {
-		links := make([]interface{}, len(names))
+		links := make([]any, len(names))
 		for i, name := range names {
 			links[i] = externalIssueLink("https://someurl.com/someUser/someRepo/", "ref-issue ref-external-issue", name)
 		}
···
 	test := func(s, expectedFmt, pattern string, ids, names []string) {
 		metas := regexpMetas
 		metas["regexp"] = pattern
-		links := make([]interface{}, len(ids))
+		links := make([]any, len(ids))
 		for i, id := range ids {
 			links[i] = link(util.URLJoin("https://someurl.com/someUser/someRepo/", id), "ref-issue ref-external-issue", names[i])
 		}

modules/markup/markdown/meta.go

···
 
 // ExtractMetadata consumes a markdown file, parses YAML frontmatter,
 // and returns the frontmatter metadata separated from the markdown content
-func ExtractMetadata(contents string, out interface{}) (string, error) {
+func ExtractMetadata(contents string, out any) (string, error) {
 	body, err := ExtractMetadataBytes([]byte(contents), out)
 	return string(body), err
 }
 
 // ExtractMetadata consumes a markdown file, parses YAML frontmatter,
 // and returns the frontmatter metadata separated from the markdown content
-func ExtractMetadataBytes(contents []byte, out interface{}) ([]byte, error) {
+func ExtractMetadataBytes(contents []byte, out any) ([]byte, error) {
 	var front, body []byte
 
 	start, end := 0, len(contents)

modules/migration/comment.go

···
 	Updated     time.Time
 	Content     string
 	Reactions   []*Reaction
-	Meta        map[string]interface{} `yaml:"meta,omitempty"` // see models/issues/comment.go for fields in Comment struct
+	Meta        map[string]any `yaml:"meta,omitempty"` // see models/issues/comment.go for fields in Comment struct
 }
 
 // GetExternalName ExternalUserMigrated interface

modules/migration/downloader.go

···
 }
 
 // DownloaderContext has opaque information only relevant to a given downloader
-type DownloaderContext interface{}
+type DownloaderContext any

modules/migration/file_format.go

···
 )
 
 // Load project data from file, with optional validation
-func Load(filename string, data interface{}, validation bool) error {
+func Load(filename string, data any, validation bool) error {
 	isJSON := strings.HasSuffix(filename, ".json")
 
 	bs, err := os.ReadFile(filename)
···
 	return unmarshal(bs, data, isJSON)
 }
 
-func unmarshal(bs []byte, data interface{}, isJSON bool) error {
+func unmarshal(bs []byte, data any, isJSON bool) error {
 	if isJSON {
 		return json.Unmarshal(bs, data)
 	}
···
 	return c.Compile(filename)
 }
 
-func validate(bs []byte, datatype interface{}, isJSON bool) error {
-	var v interface{}
+func validate(bs []byte, datatype any, isJSON bool) error {
+	var v any
 	err := unmarshal(bs, &v, isJSON)
 	if err != nil {
 		return err
···
 	return err
 }
 
-func toStringKeys(val interface{}) (interface{}, error) {
+func toStringKeys(val any) (any, error) {
 	var err error
 	switch val := val.(type) {
-	case map[string]interface{}:
-		m := make(map[string]interface{})
+	case map[string]any:
+		m := make(map[string]any)
 		for k, v := range val {
 			m[k], err = toStringKeys(v)
 			if err != nil {
···
 			}
 		}
 		return m, nil
-	case []interface{}:
-		l := make([]interface{}, len(val))
+	case []any:
+		l := make([]any, len(val))
 		for i, v := range val {
 			l[i], err = toStringKeys(v)
 			if err != nil {

modules/migration/messenger.go

···
 package migration
 
 // Messenger is a formatting function similar to i18n.Tr
-type Messenger func(key string, args ...interface{})
+type Messenger func(key string, args ...any)
 
 // NilMessenger represents an empty formatting function
-func NilMessenger(string, ...interface{}) {}
+func NilMessenger(string, ...any) {}

modules/nosql/manager_leveldb.go

···
 	// Because we want associate any goroutines created by this call to the main nosqldb context we need to
 	// wrap this in a goroutine labelled with the nosqldb context
 	done := make(chan struct{})
-	var recovered interface{}
+	var recovered any
 	go func() {
 		defer func() {
 			recovered = recover()

modules/nosql/manager_redis.go

···
 	// Because we want associate any goroutines created by this call to the main nosqldb context we need to
 	// wrap this in a goroutine labelled with the nosqldb context
 	done := make(chan struct{})
-	var recovered interface{}
+	var recovered any
 	go func() {
 		defer func() {
 			recovered = recover()

modules/packages/composer/metadata.go

···
 
 // Metadata represents the metadata of a Composer package
 type Metadata struct {
-	Description string                 `json:"description,omitempty"`
-	Keywords    []string               `json:"keywords,omitempty"`
-	Homepage    string                 `json:"homepage,omitempty"`
-	License     Licenses               `json:"license,omitempty"`
-	Authors     []Author               `json:"authors,omitempty"`
-	Autoload    map[string]interface{} `json:"autoload,omitempty"`
-	AutoloadDev map[string]interface{} `json:"autoload-dev,omitempty"`
-	Extra       map[string]interface{} `json:"extra,omitempty"`
-	Require     map[string]string      `json:"require,omitempty"`
-	RequireDev  map[string]string      `json:"require-dev,omitempty"`
-	Suggest     map[string]string      `json:"suggest,omitempty"`
-	Provide     map[string]string      `json:"provide,omitempty"`
+	Description string            `json:"description,omitempty"`
+	Keywords    []string          `json:"keywords,omitempty"`
+	Homepage    string            `json:"homepage,omitempty"`
+	License     Licenses          `json:"license,omitempty"`
+	Authors     []Author          `json:"authors,omitempty"`
+	Autoload    map[string]any    `json:"autoload,omitempty"`
+	AutoloadDev map[string]any    `json:"autoload-dev,omitempty"`
+	Extra       map[string]any    `json:"extra,omitempty"`
+	Require     map[string]string `json:"require,omitempty"`
+	RequireDev  map[string]string `json:"require-dev,omitempty"`
+	Suggest     map[string]string `json:"suggest,omitempty"`
+	Provide     map[string]string `json:"provide,omitempty"`
 }
 
 // Licenses represents the licenses of a Composer package

modules/packages/helm/metadata.go

···
 }
 
 type Dependency struct {
-	Name         string        `json:"name" yaml:"name"`
-	Version      string        `json:"version,omitempty" yaml:"version,omitempty"`
-	Repository   string        `json:"repository" yaml:"repository"`
-	Condition    string        `json:"condition,omitempty" yaml:"condition,omitempty"`
-	Tags         []string      `json:"tags,omitempty" yaml:"tags,omitempty"`
-	Enabled      bool          `json:"enabled,omitempty" yaml:"enabled,omitempty"`
-	ImportValues []interface{} `json:"import_values,omitempty" yaml:"import-values,omitempty"`
-	Alias        string        `json:"alias,omitempty" yaml:"alias,omitempty"`
+	Name         string   `json:"name" yaml:"name"`
+	Version      string   `json:"version,omitempty" yaml:"version,omitempty"`
+	Repository   string   `json:"repository" yaml:"repository"`
+	Condition    string   `json:"condition,omitempty" yaml:"condition,omitempty"`
+	Tags         []string `json:"tags,omitempty" yaml:"tags,omitempty"`
+	Enabled      bool     `json:"enabled,omitempty" yaml:"enabled,omitempty"`
+	ImportValues []any    `json:"import_values,omitempty" yaml:"import-values,omitempty"`
+	Alias        string   `json:"alias,omitempty" yaml:"alias,omitempty"`
 }
 
 // ParseChartArchive parses the metadata of a Helm archive

modules/packages/pub/metadata.go

···
 
 // Metadata represents the metadata of a Pub package
 type Metadata struct {
-	Description      string      `json:"description,omitempty"`
-	ProjectURL       string      `json:"project_url,omitempty"`
-	RepositoryURL    string      `json:"repository_url,omitempty"`
-	DocumentationURL string      `json:"documentation_url,omitempty"`
-	Readme           string      `json:"readme,omitempty"`
-	Pubspec          interface{} `json:"pubspec"`
+	Description      string `json:"description,omitempty"`
+	ProjectURL       string `json:"project_url,omitempty"`
+	RepositoryURL    string `json:"repository_url,omitempty"`
+	DocumentationURL string `json:"documentation_url,omitempty"`
+	Readme           string `json:"readme,omitempty"`
+	Pubspec          any    `json:"pubspec"`
 }
 
 type pubspecPackage struct {
···
 		p.Repository = ""
 	}
 
-	var pubspec interface{}
+	var pubspec any
 	if err := yaml.Unmarshal(buf, &pubspec); err != nil {
 		return nil, err
 	}

modules/packages/rubygems/marshal.go

···
 // RubyUserMarshal is a Ruby object that has a marshal_load function.
 type RubyUserMarshal struct {
 	Name  string
-	Value interface{}
+	Value any
 }
 
 // RubyUserDef is a Ruby object that has a _load function.
 type RubyUserDef struct {
 	Name  string
-	Value interface{}
+	Value any
 }
 
 // RubyObject is a default Ruby object.
 type RubyObject struct {
 	Name   string
-	Member map[string]interface{}
+	Member map[string]any
 }
 
 // MarshalEncoder mimics Rubys Marshal class.
···
 }
 
 // Encode encodes the given type
-func (e *MarshalEncoder) Encode(v interface{}) error {
+func (e *MarshalEncoder) Encode(v any) error {
 	if _, err := e.w.Write([]byte{majorVersion, minorVersion}); err != nil {
 		return err
 	}
···
 	return e.w.Flush()
 }
 
-func (e *MarshalEncoder) marshal(v interface{}) error {
+func (e *MarshalEncoder) marshal(v any) error {
 	if v == nil {
 		return e.marshalNil()
 	}

modules/packages/rubygems/marshal_test.go

···
 
 func TestMinimalEncoder(t *testing.T) {
 	cases := []struct {
-		Value    interface{}
+		Value    any
 		Expected []byte
 		Error    error
 	}{
···
 		{
 			Value: &RubyObject{
 				Name: "Test",
-				Member: map[string]interface{}{
+				Member: map[string]any{
 					"test": 4,
 				},
 			},

modules/packages/rubygems/metadata.go

···
 	Version struct {
 		Version string `yaml:"version"`
 	} `yaml:"version"`
-	Platform     string        `yaml:"platform"`
-	Authors      []string      `yaml:"authors"`
-	Autorequire  interface{}   `yaml:"autorequire"`
-	Bindir       string        `yaml:"bindir"`
-	CertChain    []interface{} `yaml:"cert_chain"`
-	Date         string        `yaml:"date"`
+	Platform     string   `yaml:"platform"`
+	Authors      []string `yaml:"authors"`
+	Autorequire  any      `yaml:"autorequire"`
+	Bindir       string   `yaml:"bindir"`
+	CertChain    []any    `yaml:"cert_chain"`
+	Date         string   `yaml:"date"`
 	Dependencies []struct {
 		Name                string      `yaml:"name"`
 		Requirement         requirement `yaml:"requirement"`
···
 		Prerelease          bool        `yaml:"prerelease"`
 		VersionRequirements requirement `yaml:"version_requirements"`
 	} `yaml:"dependencies"`
-	Description    string        `yaml:"description"`
-	Executables    []string      `yaml:"executables"`
-	Extensions     []interface{} `yaml:"extensions"`
-	ExtraRdocFiles []string      `yaml:"extra_rdoc_files"`
-	Files          []string      `yaml:"files"`
-	Homepage       string        `yaml:"homepage"`
-	Licenses       []string      `yaml:"licenses"`
+	Description    string   `yaml:"description"`
+	Executables    []string `yaml:"executables"`
+	Extensions     []any    `yaml:"extensions"`
+	ExtraRdocFiles []string `yaml:"extra_rdoc_files"`
+	Files          []string `yaml:"files"`
+	Homepage       string   `yaml:"homepage"`
+	Licenses       []string `yaml:"licenses"`
 	Metadata       struct {
 		BugTrackerURI    string `yaml:"bug_tracker_uri"`
 		ChangelogURI     string `yaml:"changelog_uri"`
 		DocumentationURI string `yaml:"documentation_uri"`
 		SourceCodeURI    string `yaml:"source_code_uri"`
 	} `yaml:"metadata"`
-	PostInstallMessage      interface{}   `yaml:"post_install_message"`
-	RdocOptions             []interface{} `yaml:"rdoc_options"`
-	RequirePaths            []string      `yaml:"require_paths"`
-	RequiredRubyVersion     requirement   `yaml:"required_ruby_version"`
-	RequiredRubygemsVersion requirement   `yaml:"required_rubygems_version"`
-	Requirements            []interface{} `yaml:"requirements"`
-	RubygemsVersion         string        `yaml:"rubygems_version"`
-	SigningKey              interface{}   `yaml:"signing_key"`
-	SpecificationVersion    int           `yaml:"specification_version"`
-	Summary                 string        `yaml:"summary"`
-	TestFiles               []interface{} `yaml:"test_files"`
+	PostInstallMessage      any         `yaml:"post_install_message"`
+	RdocOptions             []any       `yaml:"rdoc_options"`
+	RequirePaths            []string    `yaml:"require_paths"`
+	RequiredRubyVersion     requirement `yaml:"required_ruby_version"`
+	RequiredRubygemsVersion requirement `yaml:"required_rubygems_version"`
+	Requirements            []any       `yaml:"requirements"`
+	RubygemsVersion         string      `yaml:"rubygems_version"`
+	SigningKey              any         `yaml:"signing_key"`
+	SpecificationVersion    int         `yaml:"specification_version"`
+	Summary                 string      `yaml:"summary"`
+	TestFiles               []any       `yaml:"test_files"`
 }
 
 type requirement struct {
-	Requirements [][]interface{} `yaml:"requirements"`
+	Requirements [][]any `yaml:"requirements"`
 }
 
 // AsVersionRequirement converts into []VersionRequirement
···
 		if !ok {
 			continue
 		}
-		vm, ok := req[1].(map[string]interface{})
+		vm, ok := req[1].(map[string]any)
 		if !ok {
 			continue
 		}

modules/private/manager.go

···
 	Logger string
 	Writer string
 	Mode   string
-	Config map[string]interface{}
+	Config map[string]any
 }
 
 // AddLogger adds a logger
-func AddLogger(ctx context.Context, logger, writer, mode string, config map[string]interface{}) ResponseExtra {
+func AddLogger(ctx context.Context, logger, writer, mode string, config map[string]any) ResponseExtra {
 	reqURL := setting.LocalURL + "api/internal/manager/add-logger"
 	req := newInternalRequest(ctx, reqURL, "POST", LoggerOptions{
 		Logger: logger,

modules/process/context.go

···
 }
 
 // Value is part of the interface for context.Context. We mostly defer to the internal context - but we return this in response to the ProcessContextKey
-func (c *Context) Value(key interface{}) interface{} {
+func (c *Context) Value(key any) any {
 	if key == ProcessContextKey {
 		return c
 	}
···
 }
 
 // ProcessContextKey is the key under which process contexts are stored
-var ProcessContextKey interface{} = "process-context"
+var ProcessContextKey any = "process-context"
 
 // GetContext will return a process context if one exists
 func GetContext(ctx context.Context) *Context {

modules/session/db.go

···
 type DBStore struct {
 	sid  string
 	lock sync.RWMutex
-	data map[interface{}]interface{}
+	data map[any]any
 }
 
 // NewDBStore creates and returns a DB session store.
-func NewDBStore(sid string, kv map[interface{}]interface{}) *DBStore {
+func NewDBStore(sid string, kv map[any]any) *DBStore {
 	return &DBStore{
 		sid:  sid,
 		data: kv,
···
 }
 
 // Set sets value to given key in session.
-func (s *DBStore) Set(key, val interface{}) error {
+func (s *DBStore) Set(key, val any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 }
 
 // Get gets value by given key in session.
-func (s *DBStore) Get(key interface{}) interface{} {
+func (s *DBStore) Get(key any) any {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 
···
 }
 
 // Delete delete a key from session.
-func (s *DBStore) Delete(key interface{}) error {
+func (s *DBStore) Delete(key any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	s.data = make(map[interface{}]interface{})
+	s.data = make(map[any]any)
 	return nil
 }
 
···
 		return nil, err
 	}
 
-	var kv map[interface{}]interface{}
+	var kv map[any]any
 	if len(s.Data) == 0 || s.Expiry.Add(p.maxLifetime) <= timeutil.TimeStampNow() {
-		kv = make(map[interface{}]interface{})
+		kv = make(map[any]any)
 	} else {
 		kv, err = session.DecodeGob(s.Data)
 		if err != nil {
···
 		return nil, err
 	}
 
-	var kv map[interface{}]interface{}
+	var kv map[any]any
 	if len(s.Data) == 0 || s.Expiry.Add(p.maxLifetime) <= timeutil.TimeStampNow() {
-		kv = make(map[interface{}]interface{})
+		kv = make(map[any]any)
 	} else {
 		kv, err = session.DecodeGob(s.Data)
 		if err != nil {

modules/session/redis.go

···
 	prefix, sid string
 	duration    time.Duration
 	lock        sync.RWMutex
-	data        map[interface{}]interface{}
+	data        map[any]any
 }
 
 // NewRedisStore creates and returns a redis session store.
-func NewRedisStore(c redis.UniversalClient, prefix, sid string, dur time.Duration, kv map[interface{}]interface{}) *RedisStore {
+func NewRedisStore(c redis.UniversalClient, prefix, sid string, dur time.Duration, kv map[any]any) *RedisStore {
 	return &RedisStore{
 		c:        c,
 		prefix:   prefix,
···
 }
 
 // Set sets value to given key in session.
-func (s *RedisStore) Set(key, val interface{}) error {
+func (s *RedisStore) Set(key, val any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 }
 
 // Get gets value by given key in session.
-func (s *RedisStore) Get(key interface{}) interface{} {
+func (s *RedisStore) Get(key any) any {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 
···
 }
 
 // Delete delete a key from session.
-func (s *RedisStore) Delete(key interface{}) error {
+func (s *RedisStore) Delete(key any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	s.data = make(map[interface{}]interface{})
+	s.data = make(map[any]any)
 	return nil
 }
 
···
 		}
 	}
 
-	var kv map[interface{}]interface{}
+	var kv map[any]any
 	kvs, err := p.c.Get(graceful.GetManager().HammerContext(), psid).Result()
 	if err != nil {
 		return nil, err
 	}
 	if len(kvs) == 0 {
-		kv = make(map[interface{}]interface{})
+		kv = make(map[any]any)
 	} else {
 		kv, err = session.DecodeGob([]byte(kvs))
 		if err != nil {
···
 		return nil, err
 	}
 
-	var kv map[interface{}]interface{}
+	var kv map[any]any
 	if len(kvs) == 0 {
-		kv = make(map[interface{}]interface{})
+		kv = make(map[any]any)
 	} else {
 		kv, err = session.DecodeGob([]byte(kvs))
 		if err != nil {

modules/session/store.go

···
 
 // Store represents a session store
 type Store interface {
-	Get(interface{}) interface{}
-	Set(interface{}, interface{}) error
-	Delete(interface{}) error
+	Get(any) any
+	Set(any, any) error
+	Delete(any) error
 }
 
 // RegenerateSession regenerates the underlying session and returns the new store

modules/session/virtual.go

···
 	if o.provider.Exist(sid) {
 		return o.provider.Read(sid)
 	}
-	kv := make(map[interface{}]interface{})
+	kv := make(map[any]any)
 	kv["_old_uid"] = "0"
 	return NewVirtualStore(o, sid, kv), nil
 }
···
 	p        *VirtualSessionProvider
 	sid      string
 	lock     sync.RWMutex
-	data     map[interface{}]interface{}
+	data     map[any]any
 	released bool
 }
 
 // NewVirtualStore creates and returns a virtual session store.
-func NewVirtualStore(p *VirtualSessionProvider, sid string, kv map[interface{}]interface{}) *VirtualStore {
+func NewVirtualStore(p *VirtualSessionProvider, sid string, kv map[any]any) *VirtualStore {
 	return &VirtualStore{
 		p:    p,
 		sid:  sid,
···
 }
 
 // Set sets value to given key in session.
-func (s *VirtualStore) Set(key, val interface{}) error {
+func (s *VirtualStore) Set(key, val any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 }
 
 // Get gets value by given key in session.
-func (s *VirtualStore) Get(key interface{}) interface{} {
+func (s *VirtualStore) Get(key any) any {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 
···
 }
 
 // Delete delete a key from session.
-func (s *VirtualStore) Delete(key interface{}) error {
+func (s *VirtualStore) Delete(key any) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
···
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	s.data = make(map[interface{}]interface{})
+	s.data = make(map[any]any)
 	return nil
 }

modules/setting/cron.go

···
 import "reflect"
 
 // GetCronSettings maps the cron subsection to the provided config
-func GetCronSettings(name string, config interface{}) (interface{}, error) {
+func GetCronSettings(name string, config any) (any, error) {
 	return getCronSettings(CfgProvider, name, config)
 }
 
-func getCronSettings(rootCfg ConfigProvider, name string, config interface{}) (interface{}, error) {
+func getCronSettings(rootCfg ConfigProvider, name string, config any) (any, error) {
 	if err := rootCfg.Section("cron." + name).MapTo(config); err != nil {
 		return config, err
 	}

modules/setting/log_test.go

···
 	return manager, manager.Close
 }
 
-func toJSON(v interface{}) string {
+func toJSON(v any) string {
 	b, _ := json.MarshalIndent(v, "", "\t")
 	return string(b)
 }

modules/storage/minio.go

···
 	return os.ModePerm
 }
 
-func (m minioFileInfo) Sys() interface{} {
+func (m minioFileInfo) Sys() any {
 	return nil
 }
 

modules/storage/storage.go

···
 
 // ErrInvalidConfiguration is called when there is invalid configuration for a storage
 type ErrInvalidConfiguration struct {
-	cfg interface{}
+	cfg any
 	err error
 }
 

modules/structs/issue.go

···
 // IssueFormField represents a form field
 // swagger:model
 type IssueFormField struct {
-	Type        IssueFormFieldType     `json:"type" yaml:"type"`
-	ID          string                 `json:"id" yaml:"id"`
-	Attributes  map[string]interface{} `json:"attributes" yaml:"attributes"`
-	Validations map[string]interface{} `json:"validations" yaml:"validations"`
+	Type        IssueFormFieldType `json:"type" yaml:"type"`
+	ID          string             `json:"id" yaml:"id"`
+	Attributes  map[string]any     `json:"attributes" yaml:"attributes"`
+	Validations map[string]any     `json:"validations" yaml:"validations"`
 }
 
 // IssueTemplate represents an issue template for a repository

modules/structs/repo_file.go

···
 
 // FileDeleteResponse contains information about a repo's file that was deleted
 type FileDeleteResponse struct {
-	Content      interface{}                `json:"content"` // to be set to nil
+	Content      any                        `json:"content"` // to be set to nil
 	Commit       *FileCommitResponse        `json:"commit"`
 	Verification *PayloadCommitVerification `json:"verification"`
 }

modules/structs/repo_watch.go

···
 
 // WatchInfo represents an API watch status of one repository
 type WatchInfo struct {
-	Subscribed    bool        `json:"subscribed"`
-	Ignored       bool        `json:"ignored"`
-	Reason        interface{} `json:"reason"`
-	CreatedAt     time.Time   `json:"created_at"`
-	URL           string      `json:"url"`
-	RepositoryURL string      `json:"repository_url"`
+	Subscribed    bool      `json:"subscribed"`
+	Ignored       bool      `json:"ignored"`
+	Reason        any       `json:"reason"`
+	CreatedAt     time.Time `json:"created_at"`
+	URL           string    `json:"url"`
+	RepositoryURL string    `json:"repository_url"`
 }

modules/svg/svg.go

···
 }
 
 // RenderHTML renders icons - arguments icon name (string), size (int), class (string)
-func RenderHTML(icon string, others ...interface{}) template.HTML {
+func RenderHTML(icon string, others ...any) template.HTML {
 	size, class := html.ParseSizeAndClass(defaultSize, "", others...)
 
 	if svgStr, ok := SVGs[icon]; ok {

modules/templates/helper.go

···
 
 // NewFuncMap returns functions for injecting to templates
 func NewFuncMap() template.FuncMap {
-	return map[string]interface{}{
+	return map[string]any{
 		"DumpVar": dumpVar,
 
 		// -----------------------------------------------------------------
···
 		"DefaultTheme": func() string {
 			return setting.UI.DefaultTheme
 		},
-		"NotificationSettings": func() map[string]interface{} {
-			return map[string]interface{}{
+		"NotificationSettings": func() map[string]any {
+			return map[string]any{
 				"MinTimeout":            int(setting.UI.Notification.MinTimeout / time.Millisecond),
 				"TimeoutStep":           int(setting.UI.Notification.TimeoutStep / time.Millisecond),
 				"MaxTimeout":            int(setting.UI.Notification.MaxTimeout / time.Millisecond),

modules/templates/htmlrenderer.go

···
 
 var ErrTemplateNotInitialized = errors.New("template system is not initialized, check your log for errors")
 
-func (h *HTMLRender) HTML(w io.Writer, status int, name string, data interface{}) error {
+func (h *HTMLRender) HTML(w io.Writer, status int, name string, data any) error {
 	if respWriter, ok := w.(http.ResponseWriter); ok {
 		if respWriter.Header().Get("Content-Type") == "" {
 			respWriter.Header().Set("Content-Type", "text/html; charset=utf-8")

modules/templates/scopedtmpl/scopedtmpl.go

···
 )
 
 type TemplateExecutor interface {
-	Execute(wr io.Writer, data interface{}) error
+	Execute(wr io.Writer, data any) error
 }
 
 type ScopedTemplate struct {

modules/templates/util_avatar.go

···
 }
 
 // Avatar renders user avatars. args: user, size (int), class (string)
-func Avatar(ctx context.Context, item interface{}, others ...interface{}) template.HTML {
+func Avatar(ctx context.Context, item any, others ...any) template.HTML {
 	size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, avatars.DefaultAvatarClass, others...)
 
 	switch t := item.(type) {
···
 }
 
 // AvatarByAction renders user avatars from action. args: action, size (int), class (string)
-func AvatarByAction(ctx context.Context, action *activities_model.Action, others ...interface{}) template.HTML {
+func AvatarByAction(ctx context.Context, action *activities_model.Action, others ...any) template.HTML {
 	action.LoadActUser(ctx)
 	return Avatar(ctx, action.ActUser, others...)
 }
 
 // RepoAvatar renders repo avatars. args: repo, size(int), class (string)
-func RepoAvatar(repo *repo_model.Repository, others ...interface{}) template.HTML {
+func RepoAvatar(repo *repo_model.Repository, others ...any) template.HTML {
 	size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, avatars.DefaultAvatarClass, others...)
 
 	src := repo.RelAvatarLink()
···
 }
 
 // AvatarByEmail renders avatars by email address. args: email, name, size (int), class (string)
-func AvatarByEmail(ctx context.Context, email, name string, others ...interface{}) template.HTML {
+func AvatarByEmail(ctx context.Context, email, name string, others ...any) template.HTML {
 	size, class := gitea_html.ParseSizeAndClass(avatars.DefaultAvatarPixelSize, avatars.DefaultAvatarClass, others...)
 	src := avatars.GenerateEmailAvatarFastLink(ctx, email, size*setting.Avatar.RenderedSizeFactor)
 

modules/templates/util_misc.go

···
 	return strings.HasPrefix(mimeType, "image/")
 }
 
-func TabSizeClass(ec interface{}, filename string) string {
+func TabSizeClass(ec any, filename string) string {
 	var (
 		value *editorconfig.Editorconfig
 		ok    bool

modules/test/context_tests.go

···
 	return nil, nil
 }
 
-func (tr *mockRender) HTML(w io.Writer, status int, _ string, _ interface{}) error {
+func (tr *mockRender) HTML(w io.Writer, status int, _ string, _ any) error {
 	if resp, ok := w.(http.ResponseWriter); ok {
 		resp.WriteHeader(status)
 	}

modules/testlogger/testlogger.go

···
 }
 
 // Printf takes a format and args and prints the string to os.Stdout
-func Printf(format string, args ...interface{}) {
+func Printf(format string, args ...any) {
 	if log.CanColorStdout {
 		for i := 0; i < len(args); i++ {
 			args[i] = log.NewColoredValue(args[i])

modules/translation/i18n/format.go

···
 )
 
 // Format formats provided arguments for a given translated message
-func Format(format string, args ...interface{}) (msg string, err error) {
+func Format(format string, args ...any) (msg string, err error) {
 	if len(args) == 0 {
 		return format, nil
 	}
 
-	fmtArgs := make([]interface{}, 0, len(args))
+	fmtArgs := make([]any, 0, len(args))
 	for _, arg := range args {
 		val := reflect.ValueOf(arg)
 		if val.Kind() == reflect.Slice {

modules/translation/i18n/i18n.go

···
 
 type Locale interface {
 	// Tr translates a given key and arguments for a language
-	Tr(trKey string, trArgs ...interface{}) string
+	Tr(trKey string, trArgs ...any) string
 	// Has reports if a locale has a translation for a given key
 	Has(trKey string) bool
 }
···
 	io.Closer
 
 	// Tr translates a given key and arguments for a language
-	Tr(lang, trKey string, trArgs ...interface{}) string
+	Tr(lang, trKey string, trArgs ...any) string
 	// Has reports if a locale has a translation for a given key
 	Has(lang, trKey string) bool
 	// SetDefaultLang sets the default language to fall back to

modules/translation/i18n/localestore.go

···
 }
 
 // Tr translates content to target language. fall back to default language.
-func (store *localeStore) Tr(lang, trKey string, trArgs ...interface{}) string {
+func (store *localeStore) Tr(lang, trKey string, trArgs ...any) string {
 	l, _ := store.Locale(lang)
 
 	return l.Tr(trKey, trArgs...)
···
 }
 
 // Tr translates content to locale language. fall back to default language.
-func (l *locale) Tr(trKey string, trArgs ...interface{}) string {
+func (l *locale) Tr(trKey string, trArgs ...any) string {
 	format := trKey
 
 	idx, ok := l.store.trKeyToIdxMap[trKey]

modules/translation/mock.go

···
 	return "en"
 }
 
-func (l MockLocale) Tr(s string, _ ...interface{}) string {
+func (l MockLocale) Tr(s string, _ ...any) string {
 	return s
 }
 
-func (l MockLocale) TrN(_cnt interface{}, key1, _keyN string, _args ...interface{}) string {
+func (l MockLocale) TrN(_cnt any, key1, _keyN string, _args ...any) string {
 	return key1
 }
 

modules/util/error.go

···
 }
 
 // NewSilentWrapErrorf returns an error that formats as the given text but unwraps as the provided error
-func NewSilentWrapErrorf(unwrap error, message string, args ...interface{}) error {
+func NewSilentWrapErrorf(unwrap error, message string, args ...any) error {
 	if len(args) == 0 {
 		return SilentWrap{Message: message, Err: unwrap}
 	}
···
 }
 
 // NewInvalidArgumentErrorf returns an error that formats as the given text but unwraps as an ErrInvalidArgument
-func NewInvalidArgumentErrorf(message string, args ...interface{}) error {
+func NewInvalidArgumentErrorf(message string, args ...any) error {
 	return NewSilentWrapErrorf(ErrInvalidArgument, message, args...)
 }
 
 // NewPermissionDeniedErrorf returns an error that formats as the given text but unwraps as an ErrPermissionDenied
-func NewPermissionDeniedErrorf(message string, args ...interface{}) error {
+func NewPermissionDeniedErrorf(message string, args ...any) error {
 	return NewSilentWrapErrorf(ErrPermissionDenied, message, args...)
 }
 
 // NewAlreadyExistErrorf returns an error that formats as the given text but unwraps as an ErrAlreadyExist
-func NewAlreadyExistErrorf(message string, args ...interface{}) error {
+func NewAlreadyExistErrorf(message string, args ...any) error {
 	return NewSilentWrapErrorf(ErrAlreadyExist, message, args...)
 }
 
 // NewNotExistErrorf returns an error that formats as the given text but unwraps as an ErrNotExist
-func NewNotExistErrorf(message string, args ...interface{}) error {
+func NewNotExistErrorf(message string, args ...any) error {
 	return NewSilentWrapErrorf(ErrNotExist, message, args...)
 }

modules/util/pack.go

···
 )
 
 // PackData uses gob to encode the given data in sequence
-func PackData(data ...interface{}) ([]byte, error) {
+func PackData(data ...any) ([]byte, error) {
 	var buf bytes.Buffer
 	enc := gob.NewEncoder(&buf)
 	for _, datum := range data {
···
 }
 
 // UnpackData uses gob to decode the given data in sequence
-func UnpackData(buf []byte, data ...interface{}) error {
+func UnpackData(buf []byte, data ...any) error {
 	r := bytes.NewReader(buf)
 	enc := gob.NewDecoder(r)
 	for _, datum := range data {

modules/util/paginate.go

···
 
 // PaginateSlice cut a slice as per pagination options
 // if page = 0 it do not paginate
-func PaginateSlice(list interface{}, page, pageSize int) interface{} {
+func PaginateSlice(list any, page, pageSize int) any {
 	if page <= 0 || pageSize <= 0 {
 		return list
 	}

modules/util/rotatingfilewriter/writer.go

···
 	cancelReleaseReopen func()
 }
 
-var ErrorPrintf func(format string, args ...interface{})
+var ErrorPrintf func(format string, args ...any)
 
 // errorf tries to print error messages. Since this writer could be used by a logger system, this is the last chance to show the error in some cases
-func errorf(format string, args ...interface{}) {
+func errorf(format string, args ...any) {
 	if ErrorPrintf != nil {
 		ErrorPrintf("rotatingfilewriter: "+format+"\n", args...)
 	}

modules/util/util.go

···
 }
 
 // ToInt64 transform a given int into int64.
-func ToInt64(number interface{}) (int64, error) {
+func ToInt64(number any) (int64, error) {
 	var value int64
 	switch v := number.(type) {
 	case int:
···
 }
 
 // ToFloat64 transform a given int into float64.
-func ToFloat64(number interface{}) (float64, error) {
+func ToFloat64(number any) (float64, error) {
 	var value float64
 	switch v := number.(type) {
 	case int:

modules/validation/binding.go

···
 		IsMatch: func(rule string) bool {
 			return strings.HasPrefix(rule, "GitRefName")
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			str := fmt.Sprintf("%v", val)
 
 			if !git.IsValidRefPattern(str) {
···
 		IsMatch: func(rule string) bool {
 			return strings.HasPrefix(rule, "ValidUrl")
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			str := fmt.Sprintf("%v", val)
 			if len(str) != 0 && !IsValidURL(str) {
 				errs.Add([]string{name}, binding.ERR_URL, "Url")
···
 		IsMatch: func(rule string) bool {
 			return strings.HasPrefix(rule, "ValidSiteUrl")
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			str := fmt.Sprintf("%v", val)
 			if len(str) != 0 && !IsValidSiteURL(str) {
 				errs.Add([]string{name}, binding.ERR_URL, "Url")
···
 	})
 }
 
-func globPatternValidator(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+func globPatternValidator(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 	str := fmt.Sprintf("%v", val)
 
 	if len(str) != 0 {
···
 	})
 }
 
-func regexPatternValidator(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+func regexPatternValidator(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 	str := fmt.Sprintf("%v", val)
 
 	if _, err := regexp.Compile(str); err != nil {
···
 		IsMatch: func(rule string) bool {
 			return rule == "GlobOrRegexPattern"
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			str := strings.TrimSpace(fmt.Sprintf("%v", val))
 
 			if len(str) >= 2 && strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
···
 		IsMatch: func(rule string) bool {
 			return rule == "Username"
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			str := fmt.Sprintf("%v", val)
 			if !IsValidUsername(str) {
 				errs.Add([]string{name}, ErrUsername, "invalid username")
···
 		IsMatch: func(rule string) bool {
 			return strings.HasPrefix(rule, "ValidGroupTeamMap")
 		},
-		IsValid: func(errs binding.Errors, name string, val interface{}) (bool, binding.Errors) {
+		IsValid: func(errs binding.Errors, name string, val any) (bool, binding.Errors) {
 			_, err := auth.UnmarshalGroupTeamMapping(fmt.Sprintf("%v", val))
 			if err != nil {
 				errs.Add([]string{name}, ErrInvalidGroupTeamMap, err.Error())

modules/validation/binding_test.go

···
 type (
 	validationTestCase struct {
 		description    string
-		data           interface{}
+		data           any
 		expectedErrors binding.Errors
 	}
 

modules/web/middleware/binding.go

···
 }
 
 // AssignForm assign form values back to the template data.
-func AssignForm(form interface{}, data map[string]interface{}) {
+func AssignForm(form any, data map[string]any) {
 	typ := reflect.TypeOf(form)
 	val := reflect.ValueOf(form)
 
···
 }
 
 // Validate validate TODO:
-func Validate(errs binding.Errors, data map[string]interface{}, f Form, l translation.Locale) binding.Errors {
+func Validate(errs binding.Errors, data map[string]any, f Form, l translation.Locale) binding.Errors {
 	if errs.Len() == 0 {
 		return errs
 	}

modules/web/route.go

···
 }
 
 // SetForm set the form object
-func SetForm(dataStore middleware.ContextDataStore, obj interface{}) {
+func SetForm(dataStore middleware.ContextDataStore, obj any) {
 	dataStore.GetData()["__form"] = obj
 }
 
 // GetForm returns the validate form information
-func GetForm(dataStore middleware.ContextDataStore) interface{} {
+func GetForm(dataStore middleware.ContextDataStore) any {
 	return dataStore.GetData()["__form"]
 }
 
···
 type Route struct {
 	R              chi.Router
 	curGroupPrefix string
-	curMiddlewares []interface{}
+	curMiddlewares []any
 }
 
 // NewRoute creates a new route
···
 }
 
 // Use supports two middlewares
-func (r *Route) Use(middlewares ...interface{}) {
+func (r *Route) Use(middlewares ...any) {
 	for _, m := range middlewares {
 		r.R.Use(toHandlerProvider(m))
 	}
 }
 
 // Group mounts a sub-Router along a `pattern` string.
-func (r *Route) Group(pattern string, fn func(), middlewares ...interface{}) {
+func (r *Route) Group(pattern string, fn func(), middlewares ...any) {
 	previousGroupPrefix := r.curGroupPrefix
 	previousMiddlewares := r.curMiddlewares
 	r.curGroupPrefix += pattern
···
 }
 
 // Any delegate requests for all methods
-func (r *Route) Any(pattern string, h ...interface{}) {
+func (r *Route) Any(pattern string, h ...any) {
 	middlewares, handlerFunc := r.wrapMiddlewareAndHandler(h)
 	r.R.With(middlewares...).HandleFunc(r.getPattern(pattern), handlerFunc)
 }
 
 // RouteMethods delegate special methods, it is an alias of "Methods", while the "pattern" is the first parameter
-func (r *Route) RouteMethods(pattern, methods string, h ...interface{}) {
+func (r *Route) RouteMethods(pattern, methods string, h ...any) {
 	r.Methods(methods, pattern, h)
 }
 
 // Delete delegate delete method
-func (r *Route) Delete(pattern string, h ...interface{}) {
+func (r *Route) Delete(pattern string, h ...any) {
 	r.Methods("DELETE", pattern, h)
 }
 
 // Get delegate get method
-func (r *Route) Get(pattern string, h ...interface{}) {
+func (r *Route) Get(pattern string, h ...any) {
 	r.Methods("GET", pattern, h)
 }
 
 // GetOptions delegate get and options method
-func (r *Route) GetOptions(pattern string, h ...interface{}) {
+func (r *Route) GetOptions(pattern string, h ...any) {
 	r.Methods("GET,OPTIONS", pattern, h)
 }
 
 // PostOptions delegate post and options method
-func (r *Route) PostOptions(pattern string, h ...interface{}) {
+func (r *Route) PostOptions(pattern string, h ...any) {
 	r.Methods("POST,OPTIONS", pattern, h)
 }
 
 // Head delegate head method
-func (r *Route) Head(pattern string, h ...interface{}) {
+func (r *Route) Head(pattern string, h ...any) {
 	r.Methods("HEAD", pattern, h)
 }
 
 // Post delegate post method
-func (r *Route) Post(pattern string, h ...interface{}) {
+func (r *Route) Post(pattern string, h ...any) {
 	r.Methods("POST", pattern, h)
 }
 
 // Put delegate put method
-func (r *Route) Put(pattern string, h ...interface{}) {
+func (r *Route) Put(pattern string, h ...any) {
 	r.Methods("PUT", pattern, h)
 }
 
 // Patch delegate patch method
-func (r *Route) Patch(pattern string, h ...interface{}) {
+func (r *Route) Patch(pattern string, h ...any) {
 	r.Methods("PATCH", pattern, h)
 }
 
···
 }
 
 // Combo delegates requests to Combo
-func (r *Route) Combo(pattern string, h ...interface{}) *Combo {
+func (r *Route) Combo(pattern string, h ...any) *Combo {
 	return &Combo{r, pattern, h}
 }
 
···
 type Combo struct {
 	r       *Route
 	pattern string
-	h       []interface{}
+	h       []any
 }
 
 // Get delegates Get method
-func (c *Combo) Get(h ...interface{}) *Combo {
+func (c *Combo) Get(h ...any) *Combo {
 	c.r.Get(c.pattern, append(c.h, h...)...)
 	return c
 }
 
 // Post delegates Post method
-func (c *Combo) Post(h ...interface{}) *Combo {
+func (c *Combo) Post(h ...any) *Combo {
 	c.r.Post(c.pattern, append(c.h, h...)...)
 	return c
 }
 
 // Delete delegates Delete method
-func (c *Combo) Delete(h ...interface{}) *Combo {
+func (c *Combo) Delete(h ...any) *Combo {
 	c.r.Delete(c.pattern, append(c.h, h...)...)
 	return c
 }
 
 // Put delegates Put method
-func (c *Combo) Put(h ...interface{}) *Combo {
+func (c *Combo) Put(h ...any) *Combo {
 	c.r.Put(c.pattern, append(c.h, h...)...)
 	return c
 }
 
 // Patch delegates Patch method
-func (c *Combo) Patch(h ...interface{}) *Combo {
+func (c *Combo) Patch(h ...any) *Combo {
 	c.r.Patch(c.pattern, append(c.h, h...)...)
 	return c
 }

modules/web/routing/context.go

···
 }
 
 // UpdatePanicError updates a context's error info, a panic may be recovered by other middlewares, but we still need to know that.
-func UpdatePanicError(ctx context.Context, err interface{}) {
+func UpdatePanicError(ctx context.Context, err any) {
 	record, ok := ctx.Value(contextKey).(*requestRecord)
 	if !ok {
 		return

modules/web/routing/funcinfo.go

···
 }
 
 // GetFuncInfo returns the FuncInfo for a provided function and friendlyname
-func GetFuncInfo(fn interface{}, friendlyName ...string) *FuncInfo {
+func GetFuncInfo(fn any, friendlyName ...string) *FuncInfo {
 	// ptr represents the memory position of the function passed in as v.
 	// This will be used as program counter in FuncForPC below
 	ptr := reflect.ValueOf(fn).Pointer()

modules/web/routing/requestrecord.go

···
 	// mutable fields
 	isLongPolling bool
 	funcInfo      *FuncInfo
-	panicError    interface{}
+	panicError    any
 }

routers/api/actions/runner/utils.go

···
 }
 
 func generateTaskContext(t *actions_model.ActionTask) *structpb.Struct {
-	event := map[string]interface{}{}
+	event := map[string]any{}
 	_ = json.Unmarshal([]byte(t.Job.Run.EventPayload), &event)
 
 	// TriggerEvent is added in https://github.com/go-gitea/gitea/pull/25229
···
 
 	refName := git.RefName(t.Job.Run.Ref)
 
-	taskContext, err := structpb.NewStruct(map[string]interface{}{
+	taskContext, err := structpb.NewStruct(map[string]any{
 		// standard contexts, see https://docs.github.com/en/actions/learn-github-actions/contexts#github-context
 		"action":            "",                                                   // string, The name of the action currently running, or the id of a step. GitHub removes special characters, and uses the name __run when the current step runs a script without an id. If you use the same action more than once in the same job, the name will include a suffix with the sequence number with underscore before it. For example, the first script you run will have the name __run, and the second script will be named __run_2. Similarly, the second invocation of actions/checkout will be actionscheckout2.
 		"action_path":       "",                                                   // string, The path where an action is located. This property is only supported in composite actions. You can use this path to access files located in the same repository as the action.

routers/api/packages/alpine/alpine.go

···
 	alpine_service "code.gitea.io/gitea/services/packages/alpine"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/cargo/cargo.go

···
 	Message string `json:"detail"`
 }
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.JSON(status, StatusResponse{
 			OK: false,

routers/api/packages/chef/chef.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	type Error struct {
 		ErrorMessages []string `json:"error_messages"`
 	}

routers/api/packages/composer/composer.go

···
 	"github.com/hashicorp/go-version"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		type Error struct {
 			Status  int    `json:"status"`

routers/api/packages/conan/conan.go

···
 	)
 )
 
-func jsonResponse(ctx *context.Context, status int, obj interface{}) {
+func jsonResponse(ctx *context.Context, status int, obj any) {
 	// https://github.com/conan-io/conan/issues/6613
 	ctx.Resp.Header().Set("Content-Type", "application/json")
 	ctx.Status(status)
···
 	}
 }
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		jsonResponse(ctx, status, map[string]string{
 			"message": message,
···
 		return
 	}
 
-	files := make(map[string]interface{})
+	files := make(map[string]any)
 	for _, pf := range pfs {
 		files[pf.Name] = nil
 	}
 
 	type FileList struct {
-		Files map[string]interface{} `json:"files"`
+		Files map[string]any `json:"files"`
 	}
 
 	jsonResponse(ctx, http.StatusOK, &FileList{

routers/api/packages/conda/conda.go

···
 	"github.com/dsnet/compress/bzip2"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.JSON(status, struct {
 			Reason  string `json:"reason"`

routers/api/packages/container/container.go

···
 	resp.WriteHeader(h.Status)
 }
 
-func jsonResponse(ctx *context.Context, status int, obj interface{}) {
+func jsonResponse(ctx *context.Context, status int, obj any) {
 	setResponseHeaders(ctx.Resp, &containerHeaders{
 		Status:      status,
 		ContentType: "application/json",

routers/api/packages/cran/cran.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/debian/debian.go

···
 	debian_service "code.gitea.io/gitea/services/packages/debian"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/generic/generic.go

···
 	filenameRegex    = packageNameRegex
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/goproxy/goproxy.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/helm/helm.go

···
 	"gopkg.in/yaml.v3"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		type Error struct {
 			Error string `json:"error"`

routers/api/packages/helper/helper.go

···
 
 // LogAndProcessError logs an error and calls a custom callback with the processed error message.
 // If the error is an InternalServerError the message is stripped if the user is not an admin.
-func LogAndProcessError(ctx *context.Context, status int, obj interface{}, cb func(string)) {
+func LogAndProcessError(ctx *context.Context, status int, obj any, cb func(string)) {
 	var message string
 	if err, ok := obj.(error); ok {
 		message = err.Error()

routers/api/packages/maven/maven.go

···
 	illegalCharacters    = regexp.MustCompile(`[\\/:"<>|?\*]`)
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/npm/npm.go

···
 // errInvalidTagName indicates an invalid tag name
 var errInvalidTagName = errors.New("The tag name is invalid")
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.JSON(status, map[string]string{
 			"error": message,

routers/api/packages/nuget/nuget.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.JSON(status, map[string]string{
 			"Message": message,
···
 	})
 }
 
-func xmlResponse(ctx *context.Context, status int, obj interface{}) {
+func xmlResponse(ctx *context.Context, status int, obj any) {
 	ctx.Resp.Header().Set("Content-Type", "application/atom+xml; charset=utf-8")
 	ctx.Resp.WriteHeader(status)
 	if _, err := ctx.Resp.Write([]byte(xml.Header)); err != nil {

routers/api/packages/pub/pub.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func jsonResponse(ctx *context.Context, status int, obj interface{}) {
+func jsonResponse(ctx *context.Context, status int, obj any) {
 	resp := ctx.Resp
 	resp.Header().Set("Content-Type", "application/vnd.pub.v2+json")
 	resp.WriteHeader(status)
···
 	}
 }
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	type Error struct {
 		Code    string `json:"code"`
 		Message string `json:"message"`
···
 }
 
 type versionMetadata struct {
-	Version    string      `json:"version"`
-	ArchiveURL string      `json:"archive_url"`
-	Published  time.Time   `json:"published"`
-	Pubspec    interface{} `json:"pubspec,omitempty"`
+	Version    string    `json:"version"`
+	ArchiveURL string    `json:"archive_url"`
+	Published  time.Time `json:"published"`
+	Pubspec    any       `json:"pubspec,omitempty"`
 }
 
 func packageDescriptorToMetadata(baseURL string, pd *packages_model.PackageDescriptor) *versionMetadata {

routers/api/packages/pypi/pypi.go

···
 	`(?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)?` + // local version
 	`\z`)
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/rpm/rpm.go

···
 	rpm_service "code.gitea.io/gitea/services/packages/rpm"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})

routers/api/packages/rubygems/rubygems.go

···
 	packages_service "code.gitea.io/gitea/services/packages"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.PlainText(status, message)
 	})
···
 		return
 	}
 
-	specs := make([]interface{}, 0, len(pds))
+	specs := make([]any, 0, len(pds))
 	for _, p := range pds {
-		specs = append(specs, []interface{}{
+		specs = append(specs, []any{
 			p.Package.Name,
 			&rubygems_module.RubyUserMarshal{
 				Name:  "Gem::Version",
···
 	// create a Ruby Gem::Specification object
 	spec := &rubygems_module.RubyUserDef{
 		Name: "Gem::Specification",
-		Value: []interface{}{
+		Value: []any{
 			"3.2.3", // @rubygems_version
 			4,       // @specification_version,
 			pd.Package.Name,
···
 			nil,               // @required_ruby_version
 			nil,               // @required_rubygems_version
 			metadata.Platform, // @original_platform
-			[]interface{}{},   // @dependencies
+			[]any{},           // @dependencies
 			nil,               // rubyforge_project
 			"",                // @email
 			metadata.Authors,

routers/api/packages/swift/swift.go

···
 }
 
 // https://github.com/apple/swift-package-manager/blob/main/Documentation/Registry.md#33-error-handling
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	// https://www.rfc-editor.org/rfc/rfc7807
 	type Problem struct {
 		Status int    `json:"status"`

routers/api/packages/vagrant/vagrant.go

···
 	"github.com/hashicorp/go-version"
 )
 
-func apiError(ctx *context.Context, status int, obj interface{}) {
+func apiError(ctx *context.Context, status int, obj any) {
 	helper.LogAndProcessError(ctx, status, obj, func(message string) {
 		ctx.JSON(status, struct {
 			Errors []string `json:"errors"`

routers/api/v1/org/team.go

···
 	teams, maxResults, err := organization.SearchTeam(opts)
 	if err != nil {
 		log.Error("SearchTeam failed: %v", err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"ok":    false,
 			"error": "SearchTeam internal failure",
 		})
···
 
 	ctx.SetLinkHeader(int(maxResults), listOptions.PageSize)
 	ctx.SetTotalCountHeader(maxResults)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok":   true,
 		"data": apiTeams,
 	})

routers/api/v1/repo/repo.go

···
 		ctxUser, err = user_model.GetUserByName(ctx, form.Owner)
 		if err != nil {
 			if user_model.IsErrUserNotExist(err) {
-				ctx.JSON(http.StatusNotFound, map[string]interface{}{
+				ctx.JSON(http.StatusNotFound, map[string]any{
 					"error": "request owner `" + form.Owner + "` does not exist",
 				})
 				return

routers/api/v1/repo/topic.go

···
 	}
 
 	ctx.SetTotalCountHeader(total)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"topics": topicNames,
 	})
 }
···
 	validTopics, invalidTopics := repo_model.SanitizeAndValidateTopics(topicNames)
 
 	if len(validTopics) > 25 {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": nil,
 			"message":       "Exceeding maximum number of topics per repo",
 		})
···
 	}
 
 	if len(invalidTopics) > 0 {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": invalidTopics,
 			"message":       "Topic names are invalid",
 		})
···
 	topicName := strings.TrimSpace(strings.ToLower(ctx.Params(":topic")))
 
 	if !repo_model.ValidateTopic(topicName) {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": topicName,
 			"message":       "Topic name is invalid",
 		})
···
 		return
 	}
 	if count >= 25 {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"message": "Exceeding maximum allowed topics per repo.",
 		})
 		return
···
 	topicName := strings.TrimSpace(strings.ToLower(ctx.Params(":topic")))
 
 	if !repo_model.ValidateTopic(topicName) {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": topicName,
 			"message":       "Topic name is invalid",
 		})
···
 	}
 
 	ctx.SetTotalCountHeader(total)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"topics": topicResponses,
 	})
 }

routers/api/v1/user/user.go

···
 		ListOptions: listOptions,
 	})
 	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"ok":    false,
 			"error": err.Error(),
 		})
···
 	ctx.SetLinkHeader(int(maxResults), listOptions.PageSize)
 	ctx.SetTotalCountHeader(maxResults)
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok":   true,
 		"data": convert.ToUsers(ctx, ctx.Doer, users),
 	})

routers/private/manager_process.go

···
 	}
 
 	if json {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"TotalNumberOfGoroutines": goroutineCount,
 			"TotalNumberOfProcesses":  processCount,
 			"Processes":               processes,

routers/web/admin/auths.go

···
 
 type dropdownItem struct {
 	Name string
-	Type interface{}
+	Type any
 }
 
 var (
···
 		} else {
 			ctx.Flash.Error(fmt.Sprintf("auth_service.DeleteSource: %v", err))
 		}
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": setting.AppSubURL + "/admin/auths/" + url.PathEscape(ctx.Params(":authid")),
 		})
 		return
···
 	log.Trace("Authentication deleted by admin(%s): %d", ctx.Doer.Name, source.ID)
 
 	ctx.Flash.Success(ctx.Tr("admin.auths.deletion_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/admin/auths",
 	})
 }

routers/web/admin/config.go

···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"version": version + 1,
 	})
 }

routers/web/admin/hooks.go

···
 	ctx.Data["PageIsAdminSystemHooks"] = true
 	ctx.Data["PageIsAdminDefaultHooks"] = true
 
-	def := make(map[string]interface{}, len(ctx.Data))
-	sys := make(map[string]interface{}, len(ctx.Data))
+	def := make(map[string]any, len(ctx.Data))
+	sys := make(map[string]any, len(ctx.Data))
 	for k, v := range ctx.Data {
 		def[k] = v
 		sys[k] = v
···
 		ctx.Flash.Success(ctx.Tr("repo.settings.webhook_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/admin/hooks",
 	})
 }

routers/web/admin/packages.go

···
 	}
 
 	ctx.Flash.Success(ctx.Tr("packages.settings.delete.success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/admin/packages?page=" + url.QueryEscape(ctx.FormString("page")) + "&q=" + url.QueryEscape(ctx.FormString("q")) + "&type=" + url.QueryEscape(ctx.FormString("type")),
 	})
 }

routers/web/admin/repos.go

···
 	log.Trace("Repository deleted: %s", repo.FullName())
 
 	ctx.Flash.Success(ctx.Tr("repo.settings.deletion_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/admin/repos?page=" + url.QueryEscape(ctx.FormString("page")) + "&sort=" + url.QueryEscape(ctx.FormString("sort")),
 	})
 }

routers/web/admin/stacktrace.go

···
 func StacktraceCancel(ctx *context.Context) {
 	pid := ctx.Params("pid")
 	process.GetManager().Cancel(process.IDType(pid))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/admin/monitor/stacktrace",
 	})
 }

routers/web/admin/users.go

···
 		sortType = explore.UserSearchDefaultAdminSort
 		ctx.SetFormString("sort", sortType)
 	}
-	ctx.PageData["adminUserListSearchForm"] = map[string]interface{}{
+	ctx.PageData["adminUserListSearchForm"] = map[string]any{
 		"StatusFilterMap": statusFilterMap,
 		"SortType":        sortType,
 	}

routers/web/auth/auth.go

···
 
 	isSucceed = true
 
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		// Set session IDs
 		"uid":   u.ID,
 		"uname": u.Name,
···
 		return
 	}
 
-	updates := map[string]interface{}{
+	updates := map[string]any{
 		// User will need to use 2FA TOTP or WebAuthn, save data
 		"twofaUid":      u.ID,
 		"twofaRemember": form.Remember,
···
 		"twofaUid",
 		"twofaRemember",
 		"linkAccount",
-	}, map[string]interface{}{
+	}, map[string]any{
 		"uid":   u.ID,
 		"uname": u.Name,
 	}); err != nil {
···
 
 // createAndHandleCreatedUser calls createUserInContext and
 // then handleUserCreated.
-func createAndHandleCreatedUser(ctx *context.Context, tpl base.TplName, form interface{}, u *user_model.User, overwrites *user_model.CreateUserOverwriteOptions, gothUser *goth.User, allowLink bool) bool {
+func createAndHandleCreatedUser(ctx *context.Context, tpl base.TplName, form any, u *user_model.User, overwrites *user_model.CreateUserOverwriteOptions, gothUser *goth.User, allowLink bool) bool {
 	if !createUserInContext(ctx, tpl, form, u, overwrites, gothUser, allowLink) {
 		return false
 	}
···
 
 // createUserInContext creates a user and handles errors within a given context.
 // Optionally a template can be specified.
-func createUserInContext(ctx *context.Context, tpl base.TplName, form interface{}, u *user_model.User, overwrites *user_model.CreateUserOverwriteOptions, gothUser *goth.User, allowLink bool) (ok bool) {
+func createUserInContext(ctx *context.Context, tpl base.TplName, form any, u *user_model.User, overwrites *user_model.CreateUserOverwriteOptions, gothUser *goth.User, allowLink bool) (ok bool) {
 	if err := user_model.CreateUser(u, overwrites); err != nil {
 		if allowLink && (user_model.IsErrUserAlreadyExist(err) || user_model.IsErrEmailAlreadyUsed(err)) {
 			if setting.OAuth2Client.AccountLinking == setting.OAuth2AccountLinkingAuto {
···
 
 	log.Trace("User activated: %s", user.Name)
 
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		"uid":   user.ID,
 		"uname": user.Name,
 	}); err != nil {
···
 	ctx.Redirect(setting.AppSubURL + "/user/settings/account")
 }
 
-func updateSession(ctx *context.Context, deletes []string, updates map[string]interface{}) error {
+func updateSession(ctx *context.Context, deletes []string, updates map[string]any) error {
 	if _, err := session.RegenerateSession(ctx.Resp, ctx.Req); err != nil {
 		return fmt.Errorf("regenerate session: %w", err)
 	}

routers/web/auth/linkaccount.go

···
 		return
 	}
 
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		// User needs to use 2FA, save data and redirect to 2FA page.
 		"twofaUid":      u.ID,
 		"twofaRemember": remember,

routers/web/auth/oauth.go

···
 	handleOAuth2SignIn(ctx, authSource, u, gothUser)
 }
 
-func claimValueToStringSet(claimValue interface{}) container.Set[string] {
+func claimValueToStringSet(claimValue any) container.Set[string] {
 	var groups []string
 
 	switch rawGroup := claimValue.(type) {
 	case []string:
 		groups = rawGroup
-	case []interface{}:
+	case []any:
 		for _, group := range rawGroup {
 			groups = append(groups, fmt.Sprintf("%s", group))
 		}
···
 }
 
 func showLinkingLogin(ctx *context.Context, gothUser goth.User) {
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		"linkAccountGothUser": gothUser,
 	}); err != nil {
 		ctx.ServerError("updateSession", err)
···
 	// If this user is enrolled in 2FA and this source doesn't override it,
 	// we can't sign the user in just yet. Instead, redirect them to the 2FA authentication page.
 	if !needs2FA {
-		if err := updateSession(ctx, nil, map[string]interface{}{
+		if err := updateSession(ctx, nil, map[string]any{
 			"uid":   u.ID,
 			"uname": u.Name,
 		}); err != nil {
···
 		}
 	}
 
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		// User needs to use 2FA, save data and redirect to 2FA page.
 		"twofaUid":      u.ID,
 		"twofaRemember": false,

routers/web/auth/oauth_test.go

···
 	assert.Nil(t, terr)
 	assert.NotNil(t, response)
 
-	parsedToken, err := jwt.ParseWithClaims(response.IDToken, &oauth2.OIDCToken{}, func(token *jwt.Token) (interface{}, error) {
+	parsedToken, err := jwt.ParseWithClaims(response.IDToken, &oauth2.OIDCToken{}, func(token *jwt.Token) (any, error) {
 		assert.NotNil(t, token.Method)
 		assert.Equal(t, signingKey.SigningMethod().Alg(), token.Method.Alg())
 		return signingKey.VerifyKey(), nil

routers/web/auth/openid.go

···
 	if u != nil {
 		nickname = u.LowerName
 	}
-	if err := updateSession(ctx, nil, map[string]interface{}{
+	if err := updateSession(ctx, nil, map[string]any{
 		"openid_verified_uri":        id,
 		"openid_determined_email":    email,
 		"openid_determined_username": nickname,

routers/web/explore/topic.go

···
 	}
 
 	ctx.SetTotalCountHeader(total)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"topics": topicResponses,
 	})
 }

routers/web/org/members.go

···
 		err = models.RemoveOrgUser(org.ID, uid)
 		if organization.IsErrLastOrgOwner(err) {
 			ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
-			ctx.JSON(http.StatusOK, map[string]interface{}{
+			ctx.JSON(http.StatusOK, map[string]any{
 				"redirect": ctx.Org.OrgLink + "/members",
 			})
 			return
···
 		err = models.RemoveOrgUser(org.ID, ctx.Doer.ID)
 		if err == nil {
 			ctx.Flash.Success(ctx.Tr("form.organization_leave_success", org.DisplayName()))
-			ctx.JSON(http.StatusOK, map[string]interface{}{
+			ctx.JSON(http.StatusOK, map[string]any{
 				"redirect": "", // keep the user stay on current page, in case they want to do other operations.
 			})
 		} else if organization.IsErrLastOrgOwner(err) {
 			ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
-			ctx.JSON(http.StatusOK, map[string]interface{}{
+			ctx.JSON(http.StatusOK, map[string]any{
 				"redirect": ctx.Org.OrgLink + "/members",
 			})
 		} else {
···
 
 	if err != nil {
 		log.Error("Action(%s): %v", ctx.Params(":action"), err)
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"ok":  false,
 			"err": err.Error(),
 		})
···
 		redirect = setting.AppSubURL + "/"
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": redirect,
 	})
 }

routers/web/org/org_labels.go

···
 		ctx.Flash.Success(ctx.Tr("repo.issues.label_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Org.OrgLink + "/settings/labels",
 	})
 }

routers/web/org/projects.go

···
 		ctx.Flash.Success(ctx.Tr("repo.projects.deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.ContextUser.HomeLink() + "/-/projects",
 	})
 }
···
 		}
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }

routers/web/org/setting.go

···
 		ctx.Flash.Success(ctx.Tr("repo.settings.webhook_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Org.OrgLink + "/settings/hooks",
 	})
 }

routers/web/org/teams.go

···
 				ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
 			} else {
 				log.Error("Action(%s): %v", ctx.Params(":action"), err)
-				ctx.JSON(http.StatusOK, map[string]interface{}{
+				ctx.JSON(http.StatusOK, map[string]any{
 					"ok":  false,
 					"err": err.Error(),
 				})
···
 			redirect = setting.AppSubURL + "/"
 		}
 		ctx.JSON(http.StatusOK,
-			map[string]interface{}{
+			map[string]any{
 				"redirect": redirect,
 			})
 		return
···
 				ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
 			} else {
 				log.Error("Action(%s): %v", ctx.Params(":action"), err)
-				ctx.JSON(http.StatusOK, map[string]interface{}{
+				ctx.JSON(http.StatusOK, map[string]any{
 					"ok":  false,
 					"err": err.Error(),
 				})
···
 			}
 		}
 		ctx.JSON(http.StatusOK,
-			map[string]interface{}{
+			map[string]any{
 				"redirect": ctx.Org.OrgLink + "/teams/" + url.PathEscape(ctx.Org.Team.LowerName),
 			})
 		return
···
 			ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
 		} else {
 			log.Error("Action(%s): %v", ctx.Params(":action"), err)
-			ctx.JSON(http.StatusOK, map[string]interface{}{
+			ctx.JSON(http.StatusOK, map[string]any{
 				"ok":  false,
 				"err": err.Error(),
 			})
···
 	}
 
 	if action == "addall" || action == "removeall" {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": ctx.Org.OrgLink + "/teams/" + url.PathEscape(ctx.Org.Team.LowerName) + "/repositories",
 		})
 		return
···
 	teams, maxResults, err := org_model.SearchTeam(opts)
 	if err != nil {
 		log.Error("SearchTeam failed: %v", err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"ok":    false,
 			"error": "SearchTeam internal failure",
 		})
···
 	apiTeams, err := convert.ToTeams(ctx, teams, false)
 	if err != nil {
 		log.Error("convert ToTeams failed: %v", err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"ok":    false,
 			"error": "SearchTeam failed to get units",
 		})
···
 	}
 
 	ctx.SetTotalCountHeader(maxResults)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok":   true,
 		"data": apiTeams,
 	})
···
 		ctx.Flash.Success(ctx.Tr("org.teams.delete_team_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Org.OrgLink + "/teams",
 	})
 }

routers/web/repo/branch.go

···
 }
 
 func redirect(ctx *context.Context) {
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/branches?page=" + url.QueryEscape(ctx.FormString("page")),
 	})
 }
···
 			if len(e.Message) == 0 {
 				ctx.Flash.Error(ctx.Tr("repo.editor.push_rejected_no_message"))
 			} else {
-				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 					"Message": ctx.Tr("repo.editor.push_rejected"),
 					"Summary": ctx.Tr("repo.editor.push_rejected_summary"),
 					"Details": utils.SanitizeFlashErrorString(e.Message),

routers/web/repo/editor.go

···
 			if len(errPushRej.Message) == 0 {
 				ctx.RenderWithErr(ctx.Tr("repo.editor.push_rejected_no_message"), tplEditFile, &form)
 			} else {
-				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 					"Message": ctx.Tr("repo.editor.push_rejected"),
 					"Summary": ctx.Tr("repo.editor.push_rejected_summary"),
 					"Details": utils.SanitizeFlashErrorString(errPushRej.Message),
···
 				ctx.RenderWithErr(flashError, tplEditFile, &form)
 			}
 		} else {
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.editor.fail_to_update_file", form.TreePath),
 				"Summary": ctx.Tr("repo.editor.fail_to_update_file_summary"),
 				"Details": utils.SanitizeFlashErrorString(err.Error()),
···
 			if len(errPushRej.Message) == 0 {
 				ctx.RenderWithErr(ctx.Tr("repo.editor.push_rejected_no_message"), tplDeleteFile, &form)
 			} else {
-				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 					"Message": ctx.Tr("repo.editor.push_rejected"),
 					"Summary": ctx.Tr("repo.editor.push_rejected_summary"),
 					"Details": utils.SanitizeFlashErrorString(errPushRej.Message),
···
 			if len(errPushRej.Message) == 0 {
 				ctx.RenderWithErr(ctx.Tr("repo.editor.push_rejected_no_message"), tplUploadFile, &form)
 			} else {
-				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 					"Message": ctx.Tr("repo.editor.push_rejected"),
 					"Summary": ctx.Tr("repo.editor.push_rejected_summary"),
 					"Details": utils.SanitizeFlashErrorString(errPushRej.Message),

routers/web/repo/issue.go

···
 		lines = append(lines, fmt.Sprintf("%s: %v", file, errs[file]))
 	}
 
-	flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+	flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 		"Message": ctx.Tr("repo.issues.choose.ignore_invalid_templates"),
 		"Summary": ctx.Tr("repo.issues.choose.invalid_templates", len(errs)),
 		"Details": utils.SanitizeFlashErrorString(strings.Join(lines, "\n")),
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"title": issue.Title,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ref": ref,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"content":     content,
 		"attachments": attachmentsHTML(ctx, issue.Attachments, issue.Content),
 	})
···
 		}
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 			}
 		}
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		}
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		if issue.IsClosed != isClosed {
 			if err := issue_service.ChangeStatus(issue, ctx.Doer, "", isClosed); err != nil {
 				if issues_model.IsErrDependenciesLeft(err) {
-					ctx.JSON(http.StatusPreconditionFailed, map[string]interface{}{
+					ctx.JSON(http.StatusPreconditionFailed, map[string]any{
 						"error": ctx.Tr("repo.issues.dependency.issue_batch_close_blocked", issue.Index),
 					})
 					return
···
 	oldContent := comment.Content
 	comment.Content = ctx.FormString("content")
 	if len(comment.Content) == 0 {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"content": "",
 		})
 		return
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"content":     content,
 		"attachments": attachmentsHTML(ctx, comment.Attachments, comment.Content),
 	})
···
 	}
 
 	if len(issue.Reactions) == 0 {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"empty": true,
 			"html":  "",
 		})
 		return
 	}
 
-	html, err := ctx.RenderToString(tplReactions, map[string]interface{}{
+	html, err := ctx.RenderToString(tplReactions, map[string]any{
 		"ctxData":   ctx.Data,
 		"ActionURL": fmt.Sprintf("%s/issues/%d/reactions", ctx.Repo.RepoLink, issue.Index),
 		"Reactions": issue.Reactions.GroupByType(),
···
 		ctx.ServerError("ChangeIssueReaction.HTMLString", err)
 		return
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"html": html,
 	})
 }
···
 	}
 
 	if len(comment.Reactions) == 0 {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"empty": true,
 			"html":  "",
 		})
 		return
 	}
 
-	html, err := ctx.RenderToString(tplReactions, map[string]interface{}{
+	html, err := ctx.RenderToString(tplReactions, map[string]any{
 		"ctxData":   ctx.Data,
 		"ActionURL": fmt.Sprintf("%s/comments/%d/reactions", ctx.Repo.RepoLink, comment.ID),
 		"Reactions": comment.Reactions.GroupByType(),
···
 		ctx.ServerError("ChangeCommentReaction.HTMLString", err)
 		return
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"html": html,
 	})
 }
···
 	ctx.JSON(http.StatusOK, attachments)
 }
 
-func updateAttachments(ctx *context.Context, item interface{}, files []string) error {
+func updateAttachments(ctx *context.Context, item any, files []string) error {
 	var attachments []*repo_model.Attachment
 	switch content := item.(type) {
 	case *issues_model.Issue:
···
 }
 
 func attachmentsHTML(ctx *context.Context, attachments []*repo_model.Attachment, content string) string {
-	attachHTML, err := ctx.RenderToString(tplAttachment, map[string]interface{}{
+	attachHTML, err := ctx.RenderToString(tplAttachment, map[string]any{
 		"ctxData":     ctx.Data,
 		"Attachments": attachments,
 		"Content":     content,

routers/web/repo/issue_content_history.go

···
 	}
 
 	editedHistoryCountMap, _ := issues_model.QueryIssueContentHistoryEditedCountMap(ctx, issue.ID)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
-		"i18n": map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
+		"i18n": map[string]any{
 			"textEdited":                   ctx.Tr("repo.issues.content_history.edited"),
 			"textDeleteFromHistory":        ctx.Tr("repo.issues.content_history.delete_from_history"),
 			"textDeleteFromHistoryConfirm": ctx.Tr("repo.issues.content_history.delete_from_history_confirm"),
···
 	// render history list to HTML for frontend dropdown items: (name, value)
 	// name is HTML of "avatar + userName + userAction + timeSince"
 	// value is historyId
-	var results []map[string]interface{}
+	var results []map[string]any
 	for _, item := range items {
 		var actionText string
 		if item.IsDeleted {
···
 		avatarHTML := string(templates.AvatarHTML(src, 28, class, username))
 		timeSinceText := string(timeutil.TimeSinceUnix(item.EditedUnix, ctx.Locale))
 
-		results = append(results, map[string]interface{}{
+		results = append(results, map[string]any{
 			"name":  avatarHTML + "<strong>" + name + "</strong> " + actionText + " " + timeSinceText,
 			"value": item.HistoryID,
 		})
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"results": results,
 	})
 }
···
 	historyID := ctx.FormInt64("history_id")
 	history, prevHistory, err := issues_model.GetIssueContentHistoryAndPrev(ctx, historyID)
 	if err != nil {
-		ctx.JSON(http.StatusNotFound, map[string]interface{}{
+		ctx.JSON(http.StatusNotFound, map[string]any{
 			"message": "Can not find the content history",
 		})
 		return
···
 	}
 	diffHTMLBuf.WriteString("</pre>")
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"canSoftDelete": canSoftDeleteContentHistory(ctx, issue, comment, history),
 		"historyId":     historyID,
 		"prevHistoryId": prevHistoryID,
···
 
 	canSoftDelete := canSoftDeleteContentHistory(ctx, issue, comment, history)
 	if !canSoftDelete {
-		ctx.JSON(http.StatusForbidden, map[string]interface{}{
+		ctx.JSON(http.StatusForbidden, map[string]any{
 			"message": "Can not delete the content history",
 		})
 		return
···
 
 	err = issues_model.SoftDeleteIssueContentHistory(ctx, historyID)
 	log.Debug("soft delete issue content history. issue=%d, comment=%d, history=%d", issue.ID, commentID, historyID)
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": err == nil,
 	})
 }

routers/web/repo/issue_label.go

···
 		ctx.Flash.Success(ctx.Tr("repo.issues.label_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/labels",
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }

routers/web/repo/milestone.go

···
 		ctx.Flash.Success(ctx.Tr("repo.milestones.deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/milestones",
 	})
 }

routers/web/repo/projects.go

···
 		ctx.Flash.Success(ctx.Tr("repo.projects.deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/projects",
 	})
 }
···
 		}
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }

routers/web/repo/pull.go

···
 		return
 	}
 
-	ctx.PageData["prReview"] = map[string]interface{}{
+	ctx.PageData["prReview"] = map[string]any{
 		"numberOfFiles":       diff.NumFiles,
 		"numberOfViewedFiles": diff.NumViewedFiles,
 	}
···
 	if err = pull_service.Update(ctx, issue.PullRequest, ctx.Doer, message, rebase); err != nil {
 		if models.IsErrMergeConflicts(err) {
 			conflictError := err.(models.ErrMergeConflicts)
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.pulls.merge_conflict"),
 				"Summary": ctx.Tr("repo.pulls.merge_conflict_summary"),
 				"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
···
 			return
 		} else if models.IsErrRebaseConflicts(err) {
 			conflictError := err.(models.ErrRebaseConflicts)
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.pulls.rebase_conflict", utils.SanitizeFlashErrorString(conflictError.CommitSHA)),
 				"Summary": ctx.Tr("repo.pulls.rebase_conflict_summary"),
 				"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
···
 			ctx.Redirect(issue.Link())
 		} else if models.IsErrMergeConflicts(err) {
 			conflictError := err.(models.ErrMergeConflicts)
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.editor.merge_conflict"),
 				"Summary": ctx.Tr("repo.editor.merge_conflict_summary"),
 				"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
···
 			ctx.Redirect(issue.Link())
 		} else if models.IsErrRebaseConflicts(err) {
 			conflictError := err.(models.ErrRebaseConflicts)
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.pulls.rebase_conflict", utils.SanitizeFlashErrorString(conflictError.CommitSHA)),
 				"Summary": ctx.Tr("repo.pulls.rebase_conflict_summary"),
 				"Details": utils.SanitizeFlashErrorString(conflictError.StdErr) + "<br>" + utils.SanitizeFlashErrorString(conflictError.StdOut),
···
 			if len(message) == 0 {
 				ctx.Flash.Error(ctx.Tr("repo.pulls.push_rejected_no_message"))
 			} else {
-				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+				flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 					"Message": ctx.Tr("repo.pulls.push_rejected"),
 					"Summary": ctx.Tr("repo.pulls.push_rejected_summary"),
 					"Details": utils.SanitizeFlashErrorString(pushrejErr.Message),
···
 				ctx.JSONError(ctx.Tr("repo.pulls.push_rejected_no_message"))
 				return
 			}
-			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]interface{}{
+			flashError, err := ctx.RenderToString(tplAlertDetails, map[string]any{
 				"Message": ctx.Tr("repo.pulls.push_rejected"),
 				"Summary": ctx.Tr("repo.pulls.push_rejected_summary"),
 				"Details": utils.SanitizeFlashErrorString(pushrejErr.Message),
···
 	}
 
 	defer func() {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": issue.Link(),
 		})
 	}()
···
 			errorMessage := ctx.Tr("repo.pulls.has_pull_request", html.EscapeString(ctx.Repo.RepoLink+"/pulls/"+strconv.FormatInt(err.IssueID, 10)), html.EscapeString(RepoRelPath), err.IssueID) // FIXME: Creates url inside locale string
 
 			ctx.Flash.Error(errorMessage)
-			ctx.JSON(http.StatusConflict, map[string]interface{}{
+			ctx.JSON(http.StatusConflict, map[string]any{
 				"error":      err.Error(),
 				"user_error": errorMessage,
 			})
···
 			errorMessage := ctx.Tr("repo.pulls.is_closed")
 
 			ctx.Flash.Error(errorMessage)
-			ctx.JSON(http.StatusConflict, map[string]interface{}{
+			ctx.JSON(http.StatusConflict, map[string]any{
 				"error":      err.Error(),
 				"user_error": errorMessage,
 			})
···
 			errorMessage := ctx.Tr("repo.pulls.has_merged")
 
 			ctx.Flash.Error(errorMessage)
-			ctx.JSON(http.StatusConflict, map[string]interface{}{
+			ctx.JSON(http.StatusConflict, map[string]any{
 				"error":      err.Error(),
 				"user_error": errorMessage,
 			})
···
 			errorMessage := ctx.Tr("repo.pulls.nothing_to_compare")
 
 			ctx.Flash.Error(errorMessage)
-			ctx.JSON(http.StatusBadRequest, map[string]interface{}{
+			ctx.JSON(http.StatusBadRequest, map[string]any{
 				"error":      err.Error(),
 				"user_error": errorMessage,
 			})
···
 	}
 	notification.NotifyPullRequestChangeTargetBranch(ctx, ctx.Doer, pr, targetBranch)
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"base_branch": pr.BaseBranch,
 	})
 }
···
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"allow_maintainer_edit": pr.AllowMaintainerEdit,
 	})
 }

routers/web/repo/pull_review.go

···
 		renderConversation(ctx, comment)
 		return
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok": true,
 	})
 }

routers/web/repo/release.go

···
 	}
 
 	if isDelTag {
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": ctx.Repo.RepoLink + "/tags",
 		})
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/releases",
 	})
 }

routers/web/repo/repo.go

···
 	ctx.HTML(http.StatusOK, tplCreate)
 }
 
-func handleCreateError(ctx *context.Context, owner *user_model.User, err error, name string, tpl base.TplName, form interface{}) {
+func handleCreateError(ctx *context.Context, owner *user_model.User, err error, name string, tpl base.TplName, form any) {
 	switch {
 	case repo_model.IsErrReachLimitOfRepo(err):
 		maxCreationLimit := owner.MaxCreationLimit()
···
 		completed = true
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"complete": completed,
 	})
 }

routers/web/repo/setting/collaboration.go

···
 		ctx.Flash.Success(ctx.Tr("repo.settings.remove_collaborator_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/settings/collaboration",
 	})
 }
···
 	}
 
 	ctx.Flash.Success(ctx.Tr("repo.settings.remove_team_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/settings/collaboration",
 	})
 }

routers/web/repo/setting/deploy_key.go

···
 		ctx.Flash.Success(ctx.Tr("repo.settings.deploy_key_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/settings/keys",
 	})
 }

routers/web/repo/setting/protected_branch.go

···
 	ruleID := ctx.ParamsInt64("id")
 	if ruleID <= 0 {
 		ctx.Flash.Error(ctx.Tr("repo.settings.remove_protected_branch_failed", fmt.Sprintf("%d", ruleID)))
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": fmt.Sprintf("%s/settings/branches", ctx.Repo.RepoLink),
 		})
 		return
···
 	rule, err := git_model.GetProtectedBranchRuleByID(ctx, ctx.Repo.Repository.ID, ruleID)
 	if err != nil {
 		ctx.Flash.Error(ctx.Tr("repo.settings.remove_protected_branch_failed", fmt.Sprintf("%d", ruleID)))
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": fmt.Sprintf("%s/settings/branches", ctx.Repo.RepoLink),
 		})
 		return
···
 
 	if rule == nil {
 		ctx.Flash.Error(ctx.Tr("repo.settings.remove_protected_branch_failed", fmt.Sprintf("%d", ruleID)))
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": fmt.Sprintf("%s/settings/branches", ctx.Repo.RepoLink),
 		})
 		return
···
 
 	if err := git_model.DeleteProtectedBranch(ctx, ctx.Repo.Repository.ID, ruleID); err != nil {
 		ctx.Flash.Error(ctx.Tr("repo.settings.remove_protected_branch_failed", rule.RuleName))
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": fmt.Sprintf("%s/settings/branches", ctx.Repo.RepoLink),
 		})
 		return
 	}
 
 	ctx.Flash.Success(ctx.Tr("repo.settings.remove_protected_branch_success", rule.RuleName))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": fmt.Sprintf("%s/settings/branches", ctx.Repo.RepoLink),
 	})
 }

routers/web/repo/setting/webhook.go

···
 		return
 	}
 	if hookType == "discord" {
-		ctx.Data["DiscordHook"] = map[string]interface{}{
+		ctx.Data["DiscordHook"] = map[string]any{
 			"Username": "Gitea",
 		}
 	}
···
 	Secret      string
 	HTTPMethod  string
 	WebhookForm forms.WebhookForm
-	Meta        interface{}
+	Meta        any
 }
 
 func createWebhook(ctx *context.Context, params webhookParams) {
···
 		ctx.Flash.Success(ctx.Tr("repo.settings.webhook_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/settings/hooks",
 	})
 }

routers/web/repo/topic.go

···
 // TopicsPost response for creating repository
 func TopicsPost(ctx *context.Context) {
 	if ctx.Doer == nil {
-		ctx.JSON(http.StatusForbidden, map[string]interface{}{
+		ctx.JSON(http.StatusForbidden, map[string]any{
 			"message": "Only owners could change the topics.",
 		})
 		return
···
 	validTopics, invalidTopics := repo_model.SanitizeAndValidateTopics(topics)
 
 	if len(validTopics) > 25 {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": nil,
 			"message":       ctx.Tr("repo.topic.count_prompt"),
 		})
···
 	}
 
 	if len(invalidTopics) > 0 {
-		ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+		ctx.JSON(http.StatusUnprocessableEntity, map[string]any{
 			"invalidTopics": invalidTopics,
 			"message":       ctx.Tr("repo.topic.format_prompt"),
 		})
···
 	err := repo_model.SaveTopics(ctx.Repo.Repository.ID, validTopics...)
 	if err != nil {
 		log.Error("SaveTopics failed: %v", err)
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"message": "Save topics failed.",
 		})
 		return
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"status": "ok",
 	})
 }

routers/web/repo/wiki.go

···
 
 	notification.NotifyDeleteWikiPage(ctx, ctx.Doer, ctx.Repo.Repository, string(wikiName))
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": ctx.Repo.RepoLink + "/wiki/",
 	})
 }

routers/web/repo/wiki_test.go

···
 	assert.Nil(t, wikiEntry(t, repo, wikiName))
 }
 
-func assertPagesMetas(t *testing.T, expectedNames []string, metas interface{}) {
+func assertPagesMetas(t *testing.T, expectedNames []string, metas any) {
 	pageMetas, ok := metas.([]PageMeta)
 	if !assert.True(t, ok) {
 		return

routers/web/shared/actions/runners.go

···
 		log.Warn("DeleteRunnerPost.UpdateRunner failed: %v, url: %s", err, ctx.Req.URL)
 		ctx.Flash.Warning(ctx.Tr("actions.runners.delete_runner_failed"))
 
-		ctx.JSON(http.StatusOK, map[string]interface{}{
+		ctx.JSON(http.StatusOK, map[string]any{
 			"redirect": failedRedirectTo,
 		})
 		return
···
 
 	ctx.Flash.Success(ctx.Tr("actions.runners.delete_runner_success"))
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": successRedirectTo,
 	})
 }

routers/web/user/home.go

···
 		uid = ctxUser.ID
 	}
 
-	ctx.PageData["dashboardRepoList"] = map[string]interface{}{
+	ctx.PageData["dashboardRepoList"] = map[string]any{
 		"searchLimit": setting.UI.User.RepoPagingNum,
 		"uid":         uid,
 	}

routers/web/user/search.go

···
 		ListOptions: listOptions,
 	})
 	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"ok":    false,
 			"error": err.Error(),
 		})
···
 
 	ctx.SetTotalCountHeader(maxResults)
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"ok":   true,
 		"data": convert.ToUsers(ctx, ctx.Doer, users),
 	})

routers/web/user/setting/account.go

···
 	log.Trace("Email address deleted: %s", ctx.Doer.Name)
 
 	ctx.Flash.Success(ctx.Tr("settings.email_deletion_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/account",
 	})
 }

routers/web/user/setting/applications.go

···
 		ctx.Flash.Success(ctx.Tr("settings.delete_token_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/applications",
 	})
 }

routers/web/user/setting/keys.go

···
 		ctx.Flash.Warning("Function not implemented")
 		ctx.Redirect(setting.AppSubURL + "/user/settings/keys")
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/keys",
 	})
 }

routers/web/user/setting/oauth2_common.go

···
 	}
 
 	ctx.Flash.Success(ctx.Tr("settings.remove_oauth2_application_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{"redirect": oa.BasePathList})
+	ctx.JSON(http.StatusOK, map[string]any{"redirect": oa.BasePathList})
 }
 
 // RevokeGrant revokes the grant
···
 	}
 
 	ctx.Flash.Success(ctx.Tr("settings.revoke_oauth2_grant_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{"redirect": oa.BasePathList})
+	ctx.JSON(http.StatusOK, map[string]any{"redirect": oa.BasePathList})
 }

routers/web/user/setting/security/openid.go

···
 	log.Trace("OpenID address deleted: %s", ctx.Doer.Name)
 
 	ctx.Flash.Success(ctx.Tr("settings.openid_deletion_success"))
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/security",
 	})
 }

routers/web/user/setting/security/security.go

···
 		}
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/security",
 	})
 }

routers/web/user/setting/security/webauthn.go

···
 		ctx.ServerError("GetWebAuthnCredentialByID", err)
 		return
 	}
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/security",
 	})
 }

routers/web/user/setting/webhooks.go

···
 		ctx.Flash.Success(ctx.Tr("repo.settings.webhook_deletion_success"))
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"redirect": setting.AppSubURL + "/user/settings/hooks",
 	})
 }

routers/web/user/task.go

···
 	task, opts, err := admin_model.GetMigratingTaskByID(ctx.ParamsInt64("task"), ctx.Doer.ID)
 	if err != nil {
 		if admin_model.IsErrTaskDoesNotExist(err) {
-			ctx.JSON(http.StatusNotFound, map[string]interface{}{
+			ctx.JSON(http.StatusNotFound, map[string]any{
 				"error": "task `" + strconv.FormatInt(ctx.ParamsInt64("task"), 10) + "` does not exist",
 			})
 			return
 		}
-		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+		ctx.JSON(http.StatusInternalServerError, map[string]any{
 			"err": err,
 		})
 		return
···
 		if err := json.Unmarshal([]byte(message), &translatableMessage); err != nil {
 			translatableMessage = admin_model.TranslatableMessage{
 				Format: "migrate.migrating_failed.error",
-				Args:   []interface{}{task.Message},
+				Args:   []any{task.Message},
 			}
 		}
 		message = ctx.Tr(translatableMessage.Format, translatableMessage.Args...)
 	}
 
-	ctx.JSON(http.StatusOK, map[string]interface{}{
+	ctx.JSON(http.StatusOK, map[string]any{
 		"status":    task.Status,
 		"message":   message,
 		"repo-id":   task.RepoID,

routers/web/webfinger.go

···
 // https://datatracker.ietf.org/doc/html/draft-ietf-appsawg-webfinger-14#section-4.4
 
 type webfingerJRD struct {
-	Subject    string                 `json:"subject,omitempty"`
-	Aliases    []string               `json:"aliases,omitempty"`
-	Properties map[string]interface{} `json:"properties,omitempty"`
-	Links      []*webfingerLink       `json:"links,omitempty"`
+	Subject    string           `json:"subject,omitempty"`
+	Aliases    []string         `json:"aliases,omitempty"`
+	Properties map[string]any   `json:"properties,omitempty"`
+	Links      []*webfingerLink `json:"links,omitempty"`
 }
 
 type webfingerLink struct {
-	Rel        string                 `json:"rel,omitempty"`
-	Type       string                 `json:"type,omitempty"`
-	Href       string                 `json:"href,omitempty"`
-	Titles     map[string]string      `json:"titles,omitempty"`
-	Properties map[string]interface{} `json:"properties,omitempty"`
+	Rel        string            `json:"rel,omitempty"`
+	Type       string            `json:"type,omitempty"`
+	Href       string            `json:"href,omitempty"`
+	Titles     map[string]string `json:"titles,omitempty"`
+	Properties map[string]any    `json:"properties,omitempty"`
 }
 
 // WebfingerQuery returns information about a resource

services/auth/source/oauth2/jwtsigningkey.go

···
 type JWTSigningKey interface {
 	IsSymmetric() bool
 	SigningMethod() jwt.SigningMethod
-	SignKey() interface{}
-	VerifyKey() interface{}
+	SignKey() any
+	VerifyKey() any
 	ToJWK() (map[string]string, error)
 	PreProcessToken(*jwt.Token)
 }
···
 	return key.signingMethod
 }
 
-func (key hmacSigningKey) SignKey() interface{} {
+func (key hmacSigningKey) SignKey() any {
 	return key.secret
 }
 
-func (key hmacSigningKey) VerifyKey() interface{} {
+func (key hmacSigningKey) VerifyKey() any {
 	return key.secret
 }
 
···
 	return key.signingMethod
 }
 
-func (key rsaSingingKey) SignKey() interface{} {
+func (key rsaSingingKey) SignKey() any {
 	return key.key
 }
 
-func (key rsaSingingKey) VerifyKey() interface{} {
+func (key rsaSingingKey) VerifyKey() any {
 	return key.key.Public()
 }
 
···
 	return key.signingMethod
 }
 
-func (key eddsaSigningKey) SignKey() interface{} {
+func (key eddsaSigningKey) SignKey() any {
 	return key.key
 }
 
-func (key eddsaSigningKey) VerifyKey() interface{} {
+func (key eddsaSigningKey) VerifyKey() any {
 	return key.key.Public()
 }
 
···
 	return key.signingMethod
 }
 
-func (key ecdsaSingingKey) SignKey() interface{} {
+func (key ecdsaSingingKey) SignKey() any {
 	return key.key
 }
 
-func (key ecdsaSingingKey) VerifyKey() interface{} {
+func (key ecdsaSingingKey) VerifyKey() any {
 	return key.key.Public()
 }
 
···
 }
 
 // CreateJWTSigningKey creates a signing key from an algorithm / key pair.
-func CreateJWTSigningKey(algorithm string, key interface{}) (JWTSigningKey, error) {
+func CreateJWTSigningKey(algorithm string, key any) (JWTSigningKey, error) {
 	var signingMethod jwt.SigningMethod
 	switch algorithm {
 	case "HS256":
···
 // InitSigningKey creates the default signing key from settings or creates a random key.
 func InitSigningKey() error {
 	var err error
-	var key interface{}
+	var key any
 
 	switch setting.OAuth2.JWTSigningAlgorithm {
 	case "HS256":
···
 
 // loadSymmetricKey checks if the configured secret is valid.
 // If it is not valid, it will return an error.
-func loadSymmetricKey() (interface{}, error) {
+func loadSymmetricKey() (any, error) {
 	key := make([]byte, 32)
 	n, err := base64.RawURLEncoding.Decode(key, []byte(setting.OAuth2.JWTSecretBase64))
 	if err != nil {
···
 
 // loadOrCreateAsymmetricKey checks if the configured private key exists.
 // If it does not exist a new random key gets generated and saved on the configured path.
-func loadOrCreateAsymmetricKey() (interface{}, error) {
+func loadOrCreateAsymmetricKey() (any, error) {
 	keyPath := setting.OAuth2.JWTSigningPrivateKeyFile
 
 	isExist, err := util.IsExist(keyPath)
···
 	}
 	if !isExist {
 		err := func() error {
-			key, err := func() (interface{}, error) {
+			key, err := func() (any, error) {
 				switch {
 				case strings.HasPrefix(setting.OAuth2.JWTSigningAlgorithm, "RS"):
 					return rsa.GenerateKey(rand.Reader, 4096)

services/auth/source/oauth2/token.go

···
 
 // ParseToken parses a signed jwt string
 func ParseToken(jwtToken string, signingKey JWTSigningKey) (*Token, error) {
-	parsedToken, err := jwt.ParseWithClaims(jwtToken, &Token{}, func(token *jwt.Token) (interface{}, error) {
+	parsedToken, err := jwt.ParseWithClaims(jwtToken, &Token{}, func(token *jwt.Token) (any, error) {
 		if token.Method == nil || token.Method.Alg() != signingKey.SigningMethod().Alg() {
 			return nil, fmt.Errorf("unexpected signing algo: %v", token.Header["alg"])
 		}

services/context/user.go

···
 // UserAssignmentWeb returns a middleware to handle context-user assignment for web routes
 func UserAssignmentWeb() func(ctx *context.Context) {
 	return func(ctx *context.Context) {
-		errorFn := func(status int, title string, obj interface{}) {
+		errorFn := func(status int, title string, obj any) {
 			err, ok := obj.(error)
 			if !ok {
 				err = fmt.Errorf("%s", obj)
···
 	}
 }
 
-func userAssignment(ctx *context.Base, doer *user_model.User, errCb func(int, string, interface{})) (contextUser *user_model.User) {
+func userAssignment(ctx *context.Base, doer *user_model.User, errCb func(int, string, any)) (contextUser *user_model.User) {
 	username := ctx.Params(":username")
 
 	if doer != nil && doer.LowerName == strings.ToLower(username) {

services/cron/setting.go

···
 	IsEnabled() bool
 	DoRunAtStart() bool
 	GetSchedule() string
-	FormatMessage(locale translation.Locale, name, status, doer string, args ...interface{}) string
+	FormatMessage(locale translation.Locale, name, status, doer string, args ...any) string
 	DoNoticeOnSuccess() bool
 }
 
···
 
 // FormatMessage returns a message for the task
 // Please note the `status` string will be concatenated with `admin.dashboard.cron.` and `admin.dashboard.task.` to provide locale messages. Similarly `name` will be composed with `admin.dashboard.` to provide the locale name for the task.
-func (b *BaseConfig) FormatMessage(locale translation.Locale, name, status, doer string, args ...interface{}) string {
-	realArgs := make([]interface{}, 0, len(args)+2)
+func (b *BaseConfig) FormatMessage(locale translation.Locale, name, status, doer string, args ...any) string {
+	realArgs := make([]any, 0, len(args)+2)
 	realArgs = append(realArgs, locale.Tr("admin.dashboard."+name))
 	if doer == "" {
 		realArgs = append(realArgs, "(Cron)")

services/externalaccount/link.go

···
 
 // Store represents a thing that stores things
 type Store interface {
-	Get(interface{}) interface{}
-	Set(interface{}, interface{}) error
+	Get(any) any
+	Set(any, any) error
 	Release() error
 }
 

services/lfs/server.go

···
 	writeStatus(ctx, status)
 }
 
-func decodeJSON(req *http.Request, v interface{}) error {
+func decodeJSON(req *http.Request, v any) error {
 	defer req.Body.Close()
 
 	dec := json.NewDecoder(req.Body)
···
 	if !strings.Contains(tokenSHA, ".") {
 		return nil, nil
 	}
-	token, err := jwt.ParseWithClaims(tokenSHA, &Claims{}, func(t *jwt.Token) (interface{}, error) {
+	token, err := jwt.ParseWithClaims(tokenSHA, &Claims{}, func(t *jwt.Token) (any, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
 		}

services/mailer/incoming/incoming.go

···
 					if err := c.Store(
 						handledSet,
 						imap.FormatFlagsOp(imap.AddFlags, true),
-						[]interface{}{imap.DeletedFlag},
+						[]any{imap.DeletedFlag},
 						nil,
 					); err != nil {
 						return fmt.Errorf("imap store failed: %w", err)

services/mailer/incoming/payload/payload.go

···
 )
 
 // CreateReferencePayload creates data which GetReferenceFromPayload resolves to the reference again.
-func CreateReferencePayload(reference interface{}) ([]byte, error) {
+func CreateReferencePayload(reference any) ([]byte, error) {
 	var refType payloadReferenceType
 	var refID int64
 
···
 }
 
 // GetReferenceFromPayload resolves the reference from the payload
-func GetReferenceFromPayload(ctx context.Context, payload []byte) (interface{}, error) {
+func GetReferenceFromPayload(ctx context.Context, payload []byte) (any, error) {
 	if len(payload) < 1 {
 		return nil, util.NewInvalidArgumentErrorf("payload to small")
 	}

services/mailer/mail.go

···
 // sendUserMail sends a mail to the user
 func sendUserMail(language string, u *user_model.User, tpl base.TplName, code, subject, info string) {
 	locale := translation.NewLocale(language)
-	data := map[string]interface{}{
+	data := map[string]any{
 		"DisplayName":       u.DisplayName(),
 		"ActiveCodeLives":   timeutil.MinutesToFriendly(setting.Service.ActiveCodeLives, locale),
 		"ResetPwdCodeLives": timeutil.MinutesToFriendly(setting.Service.ResetPwdCodeLives, locale),
···
 		return
 	}
 	locale := translation.NewLocale(u.Language)
-	data := map[string]interface{}{
+	data := map[string]any{
 		"DisplayName":     u.DisplayName(),
 		"ActiveCodeLives": timeutil.MinutesToFriendly(setting.Service.ActiveCodeLives, locale),
 		"Code":            u.GenerateEmailActivateCode(email.Email),
···
 	}
 	locale := translation.NewLocale(u.Language)
 
-	data := map[string]interface{}{
+	data := map[string]any{
 		"DisplayName": u.DisplayName(),
 		"Username":    u.Name,
 		"Language":    locale.Language(),
···
 	repoName := repo.FullName()
 
 	subject := locale.Tr("mail.repo.collaborator.added.subject", doer.DisplayName(), repoName)
-	data := map[string]interface{}{
+	data := map[string]any{
 		"Subject":  subject,
 		"RepoName": repoName,
 		"Link":     repo.HTMLURL(),
···
 	}
 	locale := translation.NewLocale(lang)
 
-	mailMeta := map[string]interface{}{
+	mailMeta := map[string]any{
 		"FallbackSubject": fallback,
 		"Body":            body,
 		"Link":            link,

services/mailer/mail_release.go

···
 	}
 
 	subject := locale.Tr("mail.release.new.subject", rel.TagName, rel.Repo.FullName())
-	mailMeta := map[string]interface{}{
+	mailMeta := map[string]any{
 		"Release":  rel,
 		"Subject":  subject,
 		"Language": locale.Language(),

services/mailer/mail_repo.go

···
 		subject = locale.Tr("mail.repo.transfer.subject_to", doer.DisplayName(), repo.FullName(), destination)
 	}
 
-	data := map[string]interface{}{
+	data := map[string]any{
 		"Doer":        doer,
 		"User":        repo.Owner,
 		"Repo":        repo.FullName(),

services/mailer/mail_team_invite.go

···
 	locale := translation.NewLocale(inviter.Language)
 
 	subject := locale.Tr("mail.team_invite.subject", inviter.DisplayName(), org.DisplayName())
-	mailMeta := map[string]interface{}{
+	mailMeta := map[string]any{
 		"Inviter":      inviter,
 		"Organization": org,
 		"Team":         team,

services/migrations/codebase.go

···
 	return opts.CloneAddr, nil
 }
 
-func (d *CodebaseDownloader) callAPI(endpoint string, parameter map[string]string, result interface{}) error {
+func (d *CodebaseDownloader) callAPI(endpoint string, parameter map[string]string, result any) error {
 	u, err := d.baseURL.Parse(endpoint)
 	if err != nil {
 		return err

services/migrations/common.go

···
 )
 
 // WarnAndNotice will log the provided message and send a repository notice
-func WarnAndNotice(fmtStr string, args ...interface{}) {
+func WarnAndNotice(fmtStr string, args ...any) {
 	log.Warn(fmtStr, args...)
 	if err := system_model.CreateRepositoryNotice(fmt.Sprintf(fmtStr, args...)); err != nil {
 		log.Error("create repository notice failed: ", err)

services/migrations/dump.go

···
 	}
 	defer f.Close()
 
-	bs, err := yaml.Marshal(map[string]interface{}{
+	bs, err := yaml.Marshal(map[string]any{
 		"name":         repo.Name,
 		"owner":        repo.Owner,
 		"description":  repo.Description,
···
 	}
 	defer f.Close()
 
-	bs, err := yaml.Marshal(map[string]interface{}{
+	bs, err := yaml.Marshal(map[string]any{
 		"topics": topics,
 	})
 	if err != nil {
···
 	return nil
 }
 
-func (g *RepositoryDumper) createItems(dir string, itemFiles map[int64]*os.File, itemsMap map[int64][]interface{}) error {
+func (g *RepositoryDumper) createItems(dir string, itemFiles map[int64]*os.File, itemsMap map[int64][]any) error {
 	if err := os.MkdirAll(dir, os.ModePerm); err != nil {
 		return err
 	}
···
 	return nil
 }
 
-func (g *RepositoryDumper) encodeItems(number int64, items []interface{}, dir string, itemFiles map[int64]*os.File) error {
+func (g *RepositoryDumper) encodeItems(number int64, items []any, dir string, itemFiles map[int64]*os.File) error {
 	itemFile := itemFiles[number]
 	if itemFile == nil {
 		var err error
···
 
 // CreateComments creates comments of issues
 func (g *RepositoryDumper) CreateComments(comments ...*base.Comment) error {
-	commentsMap := make(map[int64][]interface{}, len(comments))
+	commentsMap := make(map[int64][]any, len(comments))
 	for _, comment := range comments {
 		commentsMap[comment.IssueIndex] = append(commentsMap[comment.IssueIndex], comment)
 	}
···
 
 // CreateReviews create pull request reviews
 func (g *RepositoryDumper) CreateReviews(reviews ...*base.Review) error {
-	reviewsMap := make(map[int64][]interface{}, len(reviews))
+	reviewsMap := make(map[int64][]any, len(reviews))
 	for _, review := range reviews {
 		reviewsMap[review.IssueIndex] = append(reviewsMap[review.IssueIndex], review)
 	}

services/migrations/onedev.go

···
 	return fmt.Sprintf("<OneDevDownloader %s [%d]/%s>", d.baseURL, d.repoID, d.repoName)
 }
 
-func (d *OneDevDownloader) callAPI(endpoint string, parameter map[string]string, result interface{}) error {
+func (d *OneDevDownloader) callAPI(endpoint string, parameter map[string]string, result any) error {
 	u, err := d.baseURL.Parse(endpoint)
 	if err != nil {
 		return err
···
 	}
 
 	rawChanges := make([]struct {
-		Date   time.Time              `json:"date"`
-		UserID int64                  `json:"userId"`
-		Data   map[string]interface{} `json:"data"`
+		Date   time.Time      `json:"date"`
+		UserID int64          `json:"userId"`
+		Data   map[string]any `json:"data"`
 	}, 0, 100)
 
 	if context.IsPullRequest {

services/mirror/mirror.go

···
 	}
 	log.Trace("Doing: Update")
 
-	handler := func(idx int, bean interface{}) error {
+	handler := func(idx int, bean any) error {
 		var repo *repo_model.Repository
 		var mirrorType mirror_module.SyncType
 		var referenceID int64
···
 
 	pullMirrorsRequested := 0
 	if pullLimit != 0 {
-		if err := repo_model.MirrorsIterate(pullLimit, func(idx int, bean interface{}) error {
+		if err := repo_model.MirrorsIterate(pullLimit, func(idx int, bean any) error {
 			if err := handler(idx, bean); err != nil {
 				return err
 			}
···
 
 	pushMirrorsRequested := 0
 	if pushLimit != 0 {
-		if err := repo_model.PushMirrorsIterate(ctx, pushLimit, func(idx int, bean interface{}) error {
+		if err := repo_model.PushMirrorsIterate(ctx, pushLimit, func(idx int, bean any) error {
 			if err := handler(idx, bean); err != nil {
 				return err
 			}

services/packages/auth.go

···
 		return 0, fmt.Errorf("split token failed")
 	}
 
-	token, err := jwt.ParseWithClaims(parts[1], &packageClaims{}, func(t *jwt.Token) (interface{}, error) {
+	token, err := jwt.ParseWithClaims(parts[1], &packageClaims{}, func(t *jwt.Token) (any, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
 		}

services/packages/packages.go

···
 	PackageInfo
 	SemverCompatible  bool
 	Creator           *user_model.User
-	Metadata          interface{}
+	Metadata          any
 	PackageProperties map[string]string
 	VersionProperties map[string]string
 }

services/repository/files/content.go

···
 
 // GetContentsOrList gets the meta data of a file's contents (*ContentsResponse) if treePath not a tree
 // directory, otherwise a listing of file contents ([]*ContentsResponse). Ref can be a branch, commit or tag
-func GetContentsOrList(ctx context.Context, repo *repo_model.Repository, treePath, ref string) (interface{}, error) {
+func GetContentsOrList(ctx context.Context, repo *repo_model.Repository, treePath, ref string) (any, error) {
 	if repo.IsEmpty {
-		return make([]interface{}, 0), nil
+		return make([]any, 0), nil
 	}
 	if ref == "" {
 		ref = repo.DefaultBranch

services/task/migrate.go

···
 		}
 	}()
 
-	t.Repo, err = migrations.MigrateRepository(ctx, t.Doer, t.Owner.Name, *opts, func(format string, args ...interface{}) {
+	t.Repo, err = migrations.MigrateRepository(ctx, t.Doer, t.Owner.Name, *opts, func(format string, args ...any) {
 		message := admin_model.TranslatableMessage{
 			Format: format,
 			Args:   args,

tests/integration/api_admin_test.go

···
 	})
 	resp := MakeRequest(t, req, http.StatusUnprocessableEntity)
 
-	errMap := make(map[string]interface{})
+	errMap := make(map[string]any)
 	json.Unmarshal(resp.Body.Bytes(), &errMap)
 	assert.EqualValues(t, "email is not allowed to be empty string", errMap["message"].(string))
 

tests/integration/api_packages_conan_test.go

···
 	resp := MakeRequest(t, req, http.StatusOK)
 
 	var list *struct {
-		Files map[string]interface{} `json:"files"`
+		Files map[string]any `json:"files"`
 	}
 	DecodeJSON(t, resp, &list)
 	assert.Len(t, list.Files, 1)

tests/integration/api_packages_nuget_test.go

···
 	return request
 }
 
-func decodeXML(t testing.TB, resp *httptest.ResponseRecorder, v interface{}) {
+func decodeXML(t testing.TB, resp *httptest.ResponseRecorder, v any) {
 	t.Helper()
 
 	assert.NoError(t, xml.NewDecoder(resp.Body).Decode(v))

tests/integration/api_packages_pub_test.go

···
 		resp := MakeRequest(t, req, http.StatusOK)
 
 		type VersionMetadata struct {
-			Version    string      `json:"version"`
-			ArchiveURL string      `json:"archive_url"`
-			Published  time.Time   `json:"published"`
-			Pubspec    interface{} `json:"pubspec,omitempty"`
+			Version    string    `json:"version"`
+			ArchiveURL string    `json:"archive_url"`
+			Published  time.Time `json:"published"`
+			Pubspec    any       `json:"pubspec,omitempty"`
 		}
 
 		var result VersionMetadata
···
 		resp := MakeRequest(t, req, http.StatusOK)
 
 		type VersionMetadata struct {
-			Version    string      `json:"version"`
-			ArchiveURL string      `json:"archive_url"`
-			Published  time.Time   `json:"published"`
-			Pubspec    interface{} `json:"pubspec,omitempty"`
+			Version    string    `json:"version"`
+			ArchiveURL string    `json:"archive_url"`
+			Published  time.Time `json:"published"`
+			Pubspec    any       `json:"pubspec,omitempty"`
 		}
 
 		type PackageVersions struct {

tests/integration/api_packages_rpm_test.go

···
 			assert.Contains(t, resp.Body.String(), "-----BEGIN PGP SIGNATURE-----")
 		})
 
-		decodeGzipXML := func(t testing.TB, resp *httptest.ResponseRecorder, v interface{}) {
+		decodeGzipXML := func(t testing.TB, resp *httptest.ResponseRecorder, v any) {
 			t.Helper()
 
 			zr, err := gzip.NewReader(resp.Body)

tests/integration/api_pull_review_test.go

···
 		Comments: []api.CreatePullReviewComment{},
 	})
 	resp = MakeRequest(t, req, http.StatusUnprocessableEntity)
-	errMap := make(map[string]interface{})
+	errMap := make(map[string]any)
 	json.Unmarshal(resp.Body.Bytes(), &errMap)
 	assert.EqualValues(t, "review event COMMENT requires a body or a comment", errMap["message"].(string))
 

tests/integration/api_token_test.go

···
 // createAPIAccessTokenWithoutCleanUp Create an API access token and assert that
 // creation succeeded.  The caller is responsible for deleting the token.
 func createAPIAccessTokenWithoutCleanUp(t *testing.T, tokenName string, user *user_model.User, scopes *[]auth_model.AccessTokenScope) api.AccessToken {
-	payload := map[string]interface{}{
+	payload := map[string]any{
 		"name": tokenName,
 	}
 	if scopes != nil {

tests/integration/dump_restore_test.go

···
 }
 
 type compareField struct {
-	before    interface{}
-	after     interface{}
+	before    any
+	after     any
 	ignore    bool
 	transform func(string) string
 	nested    *compareFields
···
 	}
 }
 
-func (c *compareDump) assertLoadYAMLFiles(beforeFilename, afterFilename string, before, after interface{}) {
+func (c *compareDump) assertLoadYAMLFiles(beforeFilename, afterFilename string, before, after any) {
 	_, beforeErr := os.Stat(beforeFilename)
 	_, afterErr := os.Stat(afterFilename)
 	assert.EqualValues(c.t, errors.Is(beforeErr, os.ErrNotExist), errors.Is(afterErr, os.ErrNotExist))
···
 	return beforePtr.Elem(), afterPtr.Elem()
 }
 
-func (c *compareDump) assertEqual(filename string, kind interface{}, fields compareFields) (i interface{}) {
+func (c *compareDump) assertEqual(filename string, kind any, fields compareFields) (i any) {
 	beforeFilename := filepath.Join(c.dirBefore, filename)
 	afterFilename := filepath.Join(c.dirAfter, filename)
 
···
 	return i
 }
 
-func (c *compareDump) assertEqualSlices(before, after reflect.Value, fields compareFields) interface{} {
+func (c *compareDump) assertEqualSlices(before, after reflect.Value, fields compareFields) any {
 	assert.EqualValues(c.t, before.Len(), after.Len())
 	if before.Len() == after.Len() {
 		for i := 0; i < before.Len(); i++ {
···
 	return after.Interface()
 }
 
-func (c *compareDump) assertEqualValues(before, after reflect.Value, fields compareFields) interface{} {
+func (c *compareDump) assertEqualValues(before, after reflect.Value, fields compareFields) any {
 	for _, field := range reflect.VisibleFields(before.Type()) {
 		bf := before.FieldByName(field.Name)
 		bi := bf.Interface()

tests/integration/integration_test.go

···
 	return NewRequestWithBody(t, method, urlStr, nil)
 }
 
-func NewRequestf(t testing.TB, method, urlFormat string, args ...interface{}) *http.Request {
+func NewRequestf(t testing.TB, method, urlFormat string, args ...any) *http.Request {
 	t.Helper()
 	return NewRequest(t, method, fmt.Sprintf(urlFormat, args...))
 }
···
 	return req
 }
 
-func NewRequestWithJSON(t testing.TB, method, urlStr string, v interface{}) *http.Request {
+func NewRequestWithJSON(t testing.TB, method, urlStr string, v any) *http.Request {
 	t.Helper()
 
 	jsonBytes, err := json.Marshal(v)
···
 	}
 }
 
-func DecodeJSON(t testing.TB, resp *httptest.ResponseRecorder, v interface{}) {
+func DecodeJSON(t testing.TB, resp *httptest.ResponseRecorder, v any) {
 	t.Helper()
 
 	decoder := json.NewDecoder(resp.Body)

tests/integration/webfinger_test.go

···
 	appURL, _ := url.Parse(setting.AppURL)
 
 	type webfingerLink struct {
-		Rel        string                 `json:"rel,omitempty"`
-		Type       string                 `json:"type,omitempty"`
-		Href       string                 `json:"href,omitempty"`
-		Titles     map[string]string      `json:"titles,omitempty"`
-		Properties map[string]interface{} `json:"properties,omitempty"`
+		Rel        string            `json:"rel,omitempty"`
+		Type       string            `json:"type,omitempty"`
+		Href       string            `json:"href,omitempty"`
+		Titles     map[string]string `json:"titles,omitempty"`
+		Properties map[string]any    `json:"properties,omitempty"`
 	}
 
 	type webfingerJRD struct {
-		Subject    string                 `json:"subject,omitempty"`
-		Aliases    []string               `json:"aliases,omitempty"`
-		Properties map[string]interface{} `json:"properties,omitempty"`
-		Links      []*webfingerLink       `json:"links,omitempty"`
+		Subject    string           `json:"subject,omitempty"`
+		Aliases    []string         `json:"aliases,omitempty"`
+		Properties map[string]any   `json:"properties,omitempty"`
+		Links      []*webfingerLink `json:"links,omitempty"`
 	}
 
 	session := loginUser(t, "user1")

tests/test_utils.go

···
 	"github.com/stretchr/testify/assert"
 )
 
-func exitf(format string, args ...interface{}) {
+func exitf(format string, args ...any) {
 	fmt.Printf(format+"\n", args...)
 	os.Exit(1)
 }
···
 }
 
 // Printf takes a format and args and prints the string to os.Stdout
-func Printf(format string, args ...interface{}) {
+func Printf(format string, args ...any) {
 	testlogger.Printf(format, args...)
 }