Scan composite types into struct with generic

[dagulv]

I have a problem when I try to scan a composite type into a generic struct containing the corresponding composite type in golang. For example I have a general Nullable struct and IdAndName:

type Nullable[T any] struct {
	Content T
	Valid   bool
}

// Value implements the database/sql/driver Valuer interface.
func (src Nullable[T]) Value() (driver.Value, error) {
	if !src.Valid {
		return nil, nil
	}

	switch v := any(&src.Content).(type) {
	case driver.Valuer:
		return v.Value()
	}

	return src.Content, nil
}

// Scan implements the database/sql Scanner interface.
func (dst *Nullable[T]) Scan(src any) error {
	if src == nil {
		*dst = Nullable[T]{}
		return nil
	}

	var t T

	switch v := any(&t).(type) {
	case sql.Scanner:
		if err := v.Scan(src); err != nil {
			return err
		}

		src = t
	}
	switch v := src.(type) {
	case T:
		*dst = Nullable[T]{Content: v, Valid: true}
		return nil
	}

	return fmt.Errorf("cannot scan type")
}

type IdAndName struct {
	Id   string `json:"id"`
	Name string `json:"name"`
}

type Debit struct {
	Id                string                  `json:"id"`
	Author            Nullable[IdAndName]     `json:"author"`
}

var debit Debit

row := s.db.QueryRow(ctx, `
  SELECT 
	  d."id",
	  d."author",
  FROM debits d
`)

err = row.Scan(
  &debit.Id,
  &debit.Author,
)
	
return

Since the IdAndName struct is registered it is scanned properly but when I use it in Nullable it currently needs to be handled manually. What can I do from here? Do I need to register a Codec for every corresponding composite type struct to be able to scan?