type types.Transactions has no field or method GetRlp

I am trying to create a raw transaction in go-ethereum and found some tutorial code that I was tinkering with.
The error is:

./transaction_raw_create.go:65:18: ts.GetRlp undefined (type types.Transactions has no field or method GetRlp)

The code:

package main
import (
"context"
"crypto/ecdsa"
"encoding/hex"
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/jimlawless/whereami"
)
func createRawTransaction() {
client, err := ethclient.Dial(infura.URL + infura.ID)
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
publicKey := privateKey.Public()
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
if !ok {
fmt.Println("error casting public key to ECDSA@" + whereami.WhereAmI())
}
fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
value := big.NewInt(1000000000000000000) // in wei (1 eth)
gasLimit := uint64(21000)                // in units
gasPrice, err := client.SuggestGasPrice(context.Background())
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
var data []byte
tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data)
chainID, err := client.NetworkID(context.Background())
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
if err != nil {
fmt.Println(err.Error() + "@" + whereami.WhereAmI())
}
fmt.Print("signedTx: ")
fmt.Println(signedTx)
/*	*/
ts := types.Transactions{signedTx}
rawTxBytes := ts.GetRlp(0)
rawTxHex := hex.EncodeToString(rawTxBytes)
fmt.Printf(rawTxHex) // f86...772
}

I am attempting to extract the transaction Hex value from the signed transaction.

Any suggestions on how to replace the last part?

	ts := types.Transactions{signedTx}
rawTxBytes := ts.GetRlp(0)  //<-- ts.GetRlp undefined 
rawTxHex := hex.EncodeToString(rawTxBytes)
fmt.Printf(rawTxHex) // f86...772

Not sure when it was removed, but the code previously was

import (
// ...
"github.com/ethereum/go-ethereum/rlp"
// ...
)
// GetRlp implements Rlpable and returns the i'th element of s in rlp.
func (s Transactions) GetRlp(i int) []byte {
enc, _ := rlp.EncodeToBytes(s[i])
return enc
}

And rlp.EncodeToBytes still exists, so it stands to reason that you could do

ts := types.Transactions{signedTx}
rawTxBytes, _ := rlp.EncodeToBytes(ts[0])  //<-- ts.GetRlp undefined 
rawTxHex := hex.EncodeToString(rawTxBytes)
fmt.Printf(rawTxHex) // f86...772

That being said, there seems to be a new function

func (s Transactions) EncodeIndex(i int, w *bytes.Buffer) {
tx := s[i]
if tx.Type() == LegacyTxType {
rlp.Encode(w, tx.inner)
} else {
tx.encodeTyped(w)
}
}

so I would probably try doing

b := new(bytes.Buffer)
ts.EncodeIndex(0, b)
rawTxBytes := b.Bytes()