Allow pointer or value as argument in method

I would like to be able to restrict the type tied to Auth while allowing for either a pointer or value to be passed as an argument, namely val, for the Marshal method. The Unmarshal requires a pointer, but the Marshal can be either a pointer or value without affecting functionality (all unnecessary code was removed). Is this possible?

type Auth[A any] struct {
    // ...
}

func (a *Auth[A]) Unmarshal(b []byte, val *A) error {
	// ...
	if err := json.Unmarshal(b, val); err != nil {
		return err
	}

	return nil
}

func (a *Auth[A]) Marshal(val *A) ([]byte, error) {
	b, err := json.Marshal(src)
	if err != nil {
		return nil, err
	}

	// ...
	return b, nil
}

Reasoning why I would like to be able to do this: I would like to be able to call Marshal with a basic type, eg. a string, without having to get a pointer to it.

What I would like to be able to do:

a := &Auth{}
a.Marshal("val")

Current implementation:

a := &Auth{}
s := "val"
a.Marshal(&s)

Comments:
Using Marshal(val A) will not work.
Eg.

a := Auth[string]
a.Marshal("val") // works, but only if Unmarshal uses *A

type temp struct {}
b := Auth[*temp]
b.Marshal(&temp{})
out := new(temp)
b.Unmarshal(data, &out) // this is the issue that I first presented, but now in the unmarshal

If I understand what you are trying to achieve you need to make 2 small changes:

1. operate on an A value, not *A
2. return a new A from Unmarshal() rather than accepting a *A arg

i.e.:

type Auth[A any] struct{}

func (a *Auth[A]) Unmarshal(b []byte) (A, error) {
	result := new(A)
	err := json.Unmarshal(b, result)
	return *result, err
}

func (a *Auth[A]) Marshal(val A) ([]byte, error) {
	return json.Marshal(val)
}

In use, using a string type argument and a *Foo type argument (where Foo is a struct type) (error handling omitted for clarity):

type Foo struct {
	S string
}

func main() {
	va := Auth[string]{}
	pa := Auth[*Foo]{}

    // Marshal a value type and a pointer to a Foo
	mv, _ := va.Marshal("string")
	mp, _ := pa.Marshal(&Foo{"bar"})

    // Emit the marshalled []bytes
	fmt.Printf("%s\n", mv)
	fmt.Printf("%s\n", mp)

    // Unmarshal from the marshalled []byte for
    // both the value and the pointer
	v, _ := va.Unmarshal(mv)
	p, _ := pa.Unmarshal(mp)

    // Emit the unmarshalled results and their type
	fmt.Printf("%s %[1]T\n", v)
	fmt.Printf("%s %[1]T\n", p)
}