From 9d22df3d9c67e0f9b846c834769f8cdc10f0c78d Mon Sep 17 00:00:00 2001
From: Wytse Vellema <w.vellema@slash2.nl>
Date: Fri, 29 Sep 2023 12:34:21 +0200
Subject: [PATCH 1/2] Add support to export the mock struct

---
 mocktail.go                                   |   25 +-
 mocktail_test.go                              |   59 +
 readme.md                                     |    6 +
 syrup.go                                      |   86 +-
 testdata/exported_types/a/a.go                |   43 +
 testdata/exported_types/a/b/b.go              |   14 +
 testdata/exported_types/a/c/c.go              |    5 +
 testdata/exported_types/a/go.mod              |   16 +
 testdata/exported_types/a/go.sum              |   20 +
 testdata/exported_types/a/mock_gen.go         | 3397 +++++++++++++++++
 .../exported_types/a/mock_gen_test.go.golden  | 2923 ++++++++++++++
 testdata/exported_types/a/mock_test.go        |   52 +
 12 files changed, 6590 insertions(+), 56 deletions(-)
 create mode 100644 testdata/exported_types/a/a.go
 create mode 100644 testdata/exported_types/a/b/b.go
 create mode 100644 testdata/exported_types/a/c/c.go
 create mode 100644 testdata/exported_types/a/go.mod
 create mode 100644 testdata/exported_types/a/go.sum
 create mode 100644 testdata/exported_types/a/mock_gen.go
 create mode 100644 testdata/exported_types/a/mock_gen_test.go.golden
 create mode 100644 testdata/exported_types/a/mock_test.go

diff --git a/mocktail.go b/mocktail.go
index fc9ef38..d51bc3d 100644
--- a/mocktail.go
+++ b/mocktail.go
@@ -16,6 +16,8 @@ import (
 	"path"
 	"path/filepath"
 	"strings"
+
+	"github.com/ettle/strcase"
 )
 
 const (
@@ -47,8 +49,9 @@ func main() {
 		log.Fatal("get module path", err)
 	}
 
-	var exported bool
+	var exported, exportMockTypes bool
 	flag.BoolVar(&exported, "e", false, "generate exported mocks")
+	flag.BoolVar(&exportMockTypes, "t", false, "generate exported mock types")
 	flag.Parse()
 
 	root := info.Dir
@@ -67,7 +70,7 @@ func main() {
 		return
 	}
 
-	err = generate(model, exported)
+	err = generate(model, exported, exportMockTypes)
 	if err != nil {
 		log.Fatalf("generate: %v", err)
 	}
@@ -242,7 +245,7 @@ func getTypeImports(t types.Type) []string {
 	}
 }
 
-func generate(model map[string]PackageDesc, exported bool) error {
+func generate(model map[string]PackageDesc, exported bool, exportMockTypes bool) error {
 	for fp, pkgDesc := range model {
 		buffer := bytes.NewBufferString("")
 
@@ -252,7 +255,12 @@ func generate(model map[string]PackageDesc, exported bool) error {
 		}
 
 		for _, interfaceDesc := range pkgDesc.Interfaces {
-			err = writeMockBase(buffer, interfaceDesc.Name, exported)
+			interfaceName := strcase.ToGoCamel(interfaceDesc.Name)
+			if exportMockTypes {
+				interfaceName = strcase.ToGoPascal(interfaceDesc.Name)
+			}
+
+			err = writeMockBase(buffer, interfaceDesc.Name, interfaceName, exported)
 			if err != nil {
 				return err
 			}
@@ -263,10 +271,11 @@ func generate(model map[string]PackageDesc, exported bool) error {
 				signature := method.Type().(*types.Signature)
 
 				syrup := Syrup{
-					PkgPath:       pkgDesc.Pkg.Path(),
-					InterfaceName: interfaceDesc.Name,
-					Method:        method,
-					Signature:     signature,
+					PkgPath:               pkgDesc.Pkg.Path(),
+					OriginalInterfaceName: interfaceDesc.Name,
+					Method:                method,
+					Signature:             signature,
+					InterfaceName:         interfaceName,
 				}
 
 				err = syrup.MockMethod(buffer)
diff --git a/mocktail_test.go b/mocktail_test.go
index c6968bc..a6445d6 100644
--- a/mocktail_test.go
+++ b/mocktail_test.go
@@ -129,3 +129,62 @@ func TestMocktail_exported(t *testing.T) {
 		require.NoError(t, err)
 	}
 }
+
+func TestMocktail_exported_types(t *testing.T) {
+	const testRoot = "./testdata/exported_types"
+
+	if runtime.GOOS == "windows" {
+		t.Skip(runtime.GOOS)
+	}
+
+	dir, errR := os.ReadDir(testRoot)
+	require.NoError(t, errR)
+
+	for _, entry := range dir {
+		if !entry.IsDir() {
+			continue
+		}
+
+		t.Setenv("MOCKTAIL_TEST_PATH", filepath.Join(testRoot, entry.Name()))
+
+		output, err := exec.Command("go", "run", ".", "-e", "-t").CombinedOutput()
+		t.Log(string(output))
+
+		require.NoError(t, err)
+	}
+
+	errW := filepath.WalkDir(testRoot, func(path string, d fs.DirEntry, errW error) error {
+		if errW != nil {
+			return errW
+		}
+
+		if d.IsDir() || d.Name() != outputMockFile {
+			return nil
+		}
+
+		genBytes, err := os.ReadFile(path)
+		require.NoError(t, err)
+
+		goldenBytes, err := os.ReadFile(path + ".golden")
+		require.NoError(t, err)
+
+		assert.Equal(t, string(goldenBytes), string(genBytes))
+
+		return nil
+	})
+	require.NoError(t, errW)
+
+	for _, entry := range dir {
+		if !entry.IsDir() {
+			continue
+		}
+
+		cmd := exec.Command("go", "test", "-v", "./...")
+		cmd.Dir = filepath.Join(testRoot, entry.Name())
+
+		output, err := cmd.CombinedOutput()
+		t.Log(string(output))
+
+		require.NoError(t, err)
+	}
+}
diff --git a/readme.md b/readme.md
index 4ebe006..17e8387 100644
--- a/readme.md
+++ b/readme.md
@@ -110,6 +110,12 @@ mocktail -e
 
 In this case, mock will be created in the same package but in the file `mock_gen.go`.
 
+If you need to exported mock types add flag `-t`:
+
+```shell
+mocktail -t
+```
+
 <!--
 
 Replacement pattern:
diff --git a/syrup.go b/syrup.go
index 86717e8..e36d79d 100644
--- a/syrup.go
+++ b/syrup.go
@@ -24,14 +24,14 @@ package {{ .Name }}
 `
 
 	templateMockBase = `
-// {{ .InterfaceName | ToGoCamel }}Mock mock of {{ .InterfaceName }}.
-type {{ .InterfaceName | ToGoCamel }}Mock struct { mock.Mock }
+// {{ .InterfaceName }}Mock mock of {{ .OriginalInterfaceName }}.
+type {{ .InterfaceName }}Mock struct { mock.Mock }
 
-// {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock creates a new {{ .InterfaceName | ToGoCamel }}Mock.
-func {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock(tb testing.TB) *{{ .InterfaceName | ToGoCamel }}Mock {
+// {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock creates a new {{ .InterfaceName }}Mock.
+func {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock(tb testing.TB) *{{ .InterfaceName }}Mock {
 	tb.Helper()
 
-	m := &{{ .InterfaceName | ToGoCamel }}Mock{}
+	m := &{{ .InterfaceName }}Mock{}
 	m.Mock.Test(tb)
 
 	tb.Cleanup(func() { m.AssertExpectations(tb) })
@@ -41,48 +41,48 @@ func {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock(tb testing.TB)
 `
 
 	templateCallBase = `
-type {{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call struct{
+type {{ .InterfaceName }}{{ .MethodName }}Call struct{
 	*mock.Call
-	Parent *{{ .InterfaceName | ToGoCamel }}Mock
+	Parent *{{ .InterfaceName }}Mock
 }
 
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Panic(msg string) *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Panic(msg string) *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Panic(msg)
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Once() *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Once() *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Once()
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Twice() *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Twice() *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Twice()
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Times(i int) *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Times(i int) *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Times(i)
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) WaitUntil(w <-chan time.Time) *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) WaitUntil(w <-chan time.Time) *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.WaitUntil(w)
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) After(d time.Duration) *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) After(d time.Duration) *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.After(d)
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Run(fn func(args mock.Arguments)) *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Run(fn func(args mock.Arguments)) *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Run(fn)
 	return _c
 }
 
-func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Maybe() *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call {
+func (_c *{{ .InterfaceName }}{{ .MethodName }}Call) Maybe() *{{ .InterfaceName }}{{ .MethodName }}Call {
 	_c.Call = _c.Call.Maybe()
 	return _c
 }
@@ -92,7 +92,11 @@ func (_c *{{ .InterfaceName | ToGoCamel }}{{ .MethodName }}Call) Maybe() *{{ .In
 
 // Syrup generates method mocks and mock.Call wrapper.
 type Syrup struct {
-	PkgPath       string
+	PkgPath string
+	// Contains the original interface name.
+	OriginalInterfaceName string
+	// Contains the mock interface name. The name is based on the original interface name and changes
+	// depending on the flag -t.
 	InterfaceName string
 	Method        *types.Func
 	Signature     *types.Signature
@@ -116,7 +120,7 @@ func (s Syrup) MockMethod(writer io.Writer) error {
 func (s Syrup) mockedMethod(writer io.Writer) error {
 	w := &Writer{writer: writer}
 
-	w.Printf("func (_m *%sMock) %s(", strcase.ToGoCamel(s.InterfaceName), s.Method.Name())
+	w.Printf("func (_m *%sMock) %s(", s.InterfaceName, s.Method.Name())
 
 	params := s.Signature.Params()
 
@@ -223,9 +227,7 @@ func (s Syrup) writeReturnsFnCaller(w *Writer, argNames []string, params, result
 func (s Syrup) methodOn(writer io.Writer) error {
 	w := &Writer{writer: writer}
 
-	structBaseName := strcase.ToGoCamel(s.InterfaceName)
-
-	w.Printf("func (_m *%sMock) On%s(", structBaseName, s.Method.Name())
+	w.Printf("func (_m *%sMock) On%s(", s.InterfaceName, s.Method.Name())
 
 	params := s.Signature.Params()
 
@@ -254,10 +256,10 @@ func (s Syrup) methodOn(writer io.Writer) error {
 		}
 	}
 
-	w.Printf(") *%s%sCall {\n", structBaseName, s.Method.Name())
+	w.Printf(") *%s%sCall {\n", s.InterfaceName, s.Method.Name())
 
 	w.Printf(`	return &%s%sCall{Call: _m.Mock.On("%s", %s), Parent: _m}`,
-		structBaseName, s.Method.Name(), s.Method.Name(), strings.Join(argNames, ", "))
+		s.InterfaceName, s.Method.Name(), s.Method.Name(), strings.Join(argNames, ", "))
 
 	w.Println()
 	w.Println("}")
@@ -269,9 +271,7 @@ func (s Syrup) methodOn(writer io.Writer) error {
 func (s Syrup) methodOnRaw(writer io.Writer) error {
 	w := &Writer{writer: writer}
 
-	structBaseName := strcase.ToGoCamel(s.InterfaceName)
-
-	w.Printf("func (_m *%sMock) On%sRaw(", structBaseName, s.Method.Name())
+	w.Printf("func (_m *%sMock) On%sRaw(", s.InterfaceName, s.Method.Name())
 
 	params := s.Signature.Params()
 
@@ -300,10 +300,10 @@ func (s Syrup) methodOnRaw(writer io.Writer) error {
 		}
 	}
 
-	w.Printf(") *%s%sCall {\n", structBaseName, s.Method.Name())
+	w.Printf(") *%s%sCall {\n", s.InterfaceName, s.Method.Name())
 
 	w.Printf(`	return &%s%sCall{Call: _m.Mock.On("%s", %s), Parent: _m}`,
-		structBaseName, s.Method.Name(), s.Method.Name(), strings.Join(argNames, ", "))
+		s.InterfaceName, s.Method.Name(), s.Method.Name(), strings.Join(argNames, ", "))
 
 	w.Println()
 	w.Println("}")
@@ -343,10 +343,7 @@ func (s Syrup) Call(writer io.Writer, methods []*types.Func) error {
 }
 
 func (s Syrup) callBase(writer io.Writer) error {
-	base := template.New("templateCallBase").Funcs(template.FuncMap{
-		"ToGoCamel":  strcase.ToGoCamel,
-		"ToGoPascal": strcase.ToGoPascal,
-	})
+	base := template.New("templateCallBase")
 
 	tmpl, err := base.Parse(templateCallBase)
 	if err != nil {
@@ -369,9 +366,7 @@ func (s Syrup) typedReturns(writer io.Writer) error {
 		return nil
 	}
 
-	structBaseName := strcase.ToGoCamel(s.InterfaceName)
-
-	w.Printf("func (_c *%s%sCall) TypedReturns(", structBaseName, s.Method.Name())
+	w.Printf("func (_c *%s%sCall) TypedReturns(", s.InterfaceName, s.Method.Name())
 
 	var returnNames string
 	for i := 0; i < results.Len(); i++ {
@@ -386,7 +381,7 @@ func (s Syrup) typedReturns(writer io.Writer) error {
 		}
 	}
 
-	w.Printf(") *%s%sCall {\n", structBaseName, s.Method.Name())
+	w.Printf(") *%s%sCall {\n", s.InterfaceName, s.Method.Name())
 	w.Printf("\t_c.Call = _c.Return(%s)\n", returnNames)
 	w.Println("\treturn _c")
 	w.Println("}")
@@ -400,10 +395,8 @@ func (s Syrup) typedRun(writer io.Writer) error {
 
 	params := s.Signature.Params()
 
-	structBaseName := strcase.ToGoCamel(s.InterfaceName)
-
 	w.Printf("func (_c *%[1]s%[2]sCall) TypedRun(fn %[3]s) *%[1]s%[2]sCall {\n",
-		structBaseName, s.Method.Name(), s.createFuncSignature(params, nil))
+		s.InterfaceName, s.Method.Name(), s.createFuncSignature(params, nil))
 	w.Println("\t_c.Call = _c.Call.Run(func(args mock.Arguments) {")
 
 	var pos int
@@ -454,10 +447,8 @@ func (s Syrup) returnsFn(writer io.Writer) error {
 
 	params := s.Signature.Params()
 
-	structBaseName := strcase.ToGoCamel(s.InterfaceName)
-
 	w.Printf("func (_c *%[1]s%[2]sCall) ReturnsFn(fn %[3]s) *%[1]s%[2]sCall {\n",
-		structBaseName, s.Method.Name(), s.createFuncSignature(params, results))
+		s.InterfaceName, s.Method.Name(), s.createFuncSignature(params, results))
 	w.Println("\t_c.Call = _c.Return(fn)")
 	w.Println("\treturn _c")
 	w.Println("}")
@@ -469,7 +460,7 @@ func (s Syrup) returnsFn(writer io.Writer) error {
 func (s Syrup) callMethodsOn(writer io.Writer, methods []*types.Func) error {
 	w := &Writer{writer: writer}
 
-	callType := fmt.Sprintf("%s%sCall", strcase.ToGoCamel(s.InterfaceName), s.Method.Name())
+	callType := fmt.Sprintf("%s%sCall", s.InterfaceName, s.Method.Name())
 
 	for _, method := range methods {
 		sign := method.Type().(*types.Signature)
@@ -498,7 +489,7 @@ func (s Syrup) callMethodsOn(writer io.Writer, methods []*types.Func) error {
 			}
 		}
 
-		w.Printf(") *%s%sCall {\n", strcase.ToGoCamel(s.InterfaceName), method.Name())
+		w.Printf(") *%s%sCall {\n", s.InterfaceName, method.Name())
 
 		w.Printf("\treturn _c.Parent.On%s(%s", method.Name(), strings.Join(argNames, ", "))
 		if sign.Variadic() {
@@ -515,7 +506,7 @@ func (s Syrup) callMethodsOn(writer io.Writer, methods []*types.Func) error {
 func (s Syrup) callMethodOnRaw(writer io.Writer, methods []*types.Func) error {
 	w := &Writer{writer: writer}
 
-	callType := fmt.Sprintf("%s%sCall", strcase.ToGoCamel(s.InterfaceName), s.Method.Name())
+	callType := fmt.Sprintf("%s%sCall", s.InterfaceName, s.Method.Name())
 
 	for _, method := range methods {
 		sign := method.Type().(*types.Signature)
@@ -544,7 +535,7 @@ func (s Syrup) callMethodOnRaw(writer io.Writer, methods []*types.Func) error {
 			}
 		}
 
-		w.Printf(") *%s%sCall {\n", strcase.ToGoCamel(s.InterfaceName), method.Name())
+		w.Printf(") *%s%sCall {\n", s.InterfaceName, method.Name())
 
 		w.Printf("\treturn _c.Parent.On%sRaw(%s)\n", method.Name(), strings.Join(argNames, ", "))
 		w.Println("}")
@@ -687,9 +678,8 @@ func writeImports(writer io.Writer, descPkg PackageDesc) error {
 	return tmpl.Execute(writer, data)
 }
 
-func writeMockBase(writer io.Writer, interfaceName string, exported bool) error {
+func writeMockBase(writer io.Writer, originalInterfaceName string, interfaceName string, exported bool) error {
 	base := template.New("templateMockBase").Funcs(template.FuncMap{
-		"ToGoCamel":  strcase.ToGoCamel,
 		"ToGoPascal": strcase.ToGoPascal,
 	})
 
@@ -703,7 +693,7 @@ func writeMockBase(writer io.Writer, interfaceName string, exported bool) error
 		return err
 	}
 
-	return tmpl.Execute(writer, map[string]interface{}{"InterfaceName": interfaceName, "ConstructorPrefix": constructorPrefix})
+	return tmpl.Execute(writer, map[string]interface{}{"OriginalInterfaceName": originalInterfaceName, "InterfaceName": interfaceName, "ConstructorPrefix": constructorPrefix})
 }
 
 func quickGoImports(descPkg PackageDesc) []string {
diff --git a/testdata/exported_types/a/a.go b/testdata/exported_types/a/a.go
new file mode 100644
index 0000000..99c895e
--- /dev/null
+++ b/testdata/exported_types/a/a.go
@@ -0,0 +1,43 @@
+package a
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"golang.org/x/mod/module"
+)
+
+type Pineapple interface {
+	Hello(bar Water) string
+	World() string
+	Goo() (string, int, Water)
+	Coo(context.Context, string, Water) Water
+	Noo(context.Context) string
+}
+
+type Coconut interface {
+	Boo(src *bytes.Buffer) time.Duration
+	Doo(src time.Duration) time.Duration
+	Foo(st Strawberry) string
+	Goo(st string) Strawberry
+	Hoo(string, int, Water)
+	Joo(string, int, Water) (string, int)
+	Koo(src string) (dst string)
+	Loo(st string, values ...int) string
+	Too(src string) time.Duration
+	Voo(src *module.Version) time.Duration
+	Yoo(st string) interface{}
+	Zoo(st interface{}) string
+	Moo(fn func(st, stban Strawberry) Pineapple) string
+}
+
+type Water struct{}
+
+type Strawberry interface {
+	Bar(string) int
+}
+
+type Orange interface {
+	Juice() <-chan struct{}
+}
diff --git a/testdata/exported_types/a/b/b.go b/testdata/exported_types/a/b/b.go
new file mode 100644
index 0000000..1181d07
--- /dev/null
+++ b/testdata/exported_types/a/b/b.go
@@ -0,0 +1,14 @@
+package b
+
+import (
+	"a/c"
+)
+
+type Carrot interface {
+	Bar(string) *Potato
+	Bur(string) *c.Cherry
+}
+
+type Potato struct {
+	Name string
+}
diff --git a/testdata/exported_types/a/c/c.go b/testdata/exported_types/a/c/c.go
new file mode 100644
index 0000000..e4fed55
--- /dev/null
+++ b/testdata/exported_types/a/c/c.go
@@ -0,0 +1,5 @@
+package c
+
+type Cherry struct {
+	Name string
+}
diff --git a/testdata/exported_types/a/go.mod b/testdata/exported_types/a/go.mod
new file mode 100644
index 0000000..627f9ee
--- /dev/null
+++ b/testdata/exported_types/a/go.mod
@@ -0,0 +1,16 @@
+module a
+
+go 1.18
+
+require (
+	github.com/stretchr/testify v1.8.0
+	golang.org/x/mod v0.5.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/objx v0.4.0 // indirect
+	golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/testdata/exported_types/a/go.sum b/testdata/exported_types/a/go.sum
new file mode 100644
index 0000000..0c98ef7
--- /dev/null
+++ b/testdata/exported_types/a/go.sum
@@ -0,0 +1,20 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
+golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/testdata/exported_types/a/mock_gen.go b/testdata/exported_types/a/mock_gen.go
new file mode 100644
index 0000000..29561a6
--- /dev/null
+++ b/testdata/exported_types/a/mock_gen.go
@@ -0,0 +1,3397 @@
+// Code generated by mocktail; DO NOT EDIT.
+
+package a
+
+import (
+	"a/b"
+	"a/c"
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/mock"
+	"golang.org/x/mod/module"
+)
+
+// PineappleMock mock of Pineapple.
+type PineappleMock struct{ mock.Mock }
+
+// NewPineappleMock creates a new PineappleMock.
+func NewPineappleMock(tb testing.TB) *PineappleMock {
+	tb.Helper()
+
+	m := &PineappleMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *PineappleMock) Coo(_ context.Context, bParam string, cParam Water) Water {
+	_ret := _m.Called(bParam, cParam)
+
+	if _rf, ok := _ret.Get(0).(func(string, Water) Water); ok {
+		return _rf(bParam, cParam)
+	}
+
+	_ra0, _ := _ret.Get(0).(Water)
+
+	return _ra0
+}
+
+func (_m *PineappleMock) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return &PineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m}
+}
+
+func (_m *PineappleMock) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return &PineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m}
+}
+
+type PineappleCooCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleCooCall) Panic(msg string) *PineappleCooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleCooCall) Once() *PineappleCooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleCooCall) Twice() *PineappleCooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleCooCall) Times(i int) *PineappleCooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleCooCall) WaitUntil(w <-chan time.Time) *PineappleCooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleCooCall) After(d time.Duration) *PineappleCooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleCooCall) Run(fn func(args mock.Arguments)) *PineappleCooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleCooCall) Maybe() *PineappleCooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleCooCall) TypedReturns(a Water) *PineappleCooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *PineappleCooCall) ReturnsFn(fn func(string, Water) Water) *PineappleCooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleCooCall) TypedRun(fn func(string, Water)) *PineappleCooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_bParam := args.String(0)
+		_cParam, _ := args.Get(1).(Water)
+		fn(_bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *PineappleCooCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleCooCall) OnGoo() *PineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleCooCall) OnHello(bar Water) *PineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleCooCall) OnNoo() *PineappleNooCall {
+	return _c.Parent.OnNoo()
+}
+
+func (_c *PineappleCooCall) OnWorld() *PineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleCooCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleCooCall) OnGooRaw() *PineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleCooCall) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleCooCall) OnNooRaw() *PineappleNooCall {
+	return _c.Parent.OnNooRaw()
+}
+
+func (_c *PineappleCooCall) OnWorldRaw() *PineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *PineappleMock) Goo() (string, int, Water) {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() (string, int, Water)); ok {
+		return _rf()
+	}
+
+	_ra0 := _ret.String(0)
+	_rb1 := _ret.Int(1)
+	_rc2, _ := _ret.Get(2).(Water)
+
+	return _ra0, _rb1, _rc2
+}
+
+func (_m *PineappleMock) OnGoo() *PineappleGooCall {
+	return &PineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m}
+}
+
+func (_m *PineappleMock) OnGooRaw() *PineappleGooCall {
+	return &PineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m}
+}
+
+type PineappleGooCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleGooCall) Panic(msg string) *PineappleGooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleGooCall) Once() *PineappleGooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleGooCall) Twice() *PineappleGooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleGooCall) Times(i int) *PineappleGooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleGooCall) WaitUntil(w <-chan time.Time) *PineappleGooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleGooCall) After(d time.Duration) *PineappleGooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleGooCall) Run(fn func(args mock.Arguments)) *PineappleGooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleGooCall) Maybe() *PineappleGooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleGooCall) TypedReturns(a string, b int, c Water) *PineappleGooCall {
+	_c.Call = _c.Return(a, b, c)
+	return _c
+}
+
+func (_c *PineappleGooCall) ReturnsFn(fn func() (string, int, Water)) *PineappleGooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleGooCall) TypedRun(fn func()) *PineappleGooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *PineappleGooCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleGooCall) OnGoo() *PineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleGooCall) OnHello(bar Water) *PineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleGooCall) OnNoo() *PineappleNooCall {
+	return _c.Parent.OnNoo()
+}
+
+func (_c *PineappleGooCall) OnWorld() *PineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleGooCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleGooCall) OnGooRaw() *PineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleGooCall) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleGooCall) OnNooRaw() *PineappleNooCall {
+	return _c.Parent.OnNooRaw()
+}
+
+func (_c *PineappleGooCall) OnWorldRaw() *PineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *PineappleMock) Hello(bar Water) string {
+	_ret := _m.Called(bar)
+
+	if _rf, ok := _ret.Get(0).(func(Water) string); ok {
+		return _rf(bar)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *PineappleMock) OnHello(bar Water) *PineappleHelloCall {
+	return &PineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m}
+}
+
+func (_m *PineappleMock) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return &PineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m}
+}
+
+type PineappleHelloCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleHelloCall) Panic(msg string) *PineappleHelloCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleHelloCall) Once() *PineappleHelloCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleHelloCall) Twice() *PineappleHelloCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleHelloCall) Times(i int) *PineappleHelloCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleHelloCall) WaitUntil(w <-chan time.Time) *PineappleHelloCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleHelloCall) After(d time.Duration) *PineappleHelloCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleHelloCall) Run(fn func(args mock.Arguments)) *PineappleHelloCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleHelloCall) Maybe() *PineappleHelloCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleHelloCall) TypedReturns(a string) *PineappleHelloCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *PineappleHelloCall) ReturnsFn(fn func(Water) string) *PineappleHelloCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleHelloCall) TypedRun(fn func(Water)) *PineappleHelloCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_bar, _ := args.Get(0).(Water)
+		fn(_bar)
+	})
+	return _c
+}
+
+func (_c *PineappleHelloCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleHelloCall) OnGoo() *PineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleHelloCall) OnHello(bar Water) *PineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleHelloCall) OnNoo() *PineappleNooCall {
+	return _c.Parent.OnNoo()
+}
+
+func (_c *PineappleHelloCall) OnWorld() *PineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleHelloCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleHelloCall) OnGooRaw() *PineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleHelloCall) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleHelloCall) OnNooRaw() *PineappleNooCall {
+	return _c.Parent.OnNooRaw()
+}
+
+func (_c *PineappleHelloCall) OnWorldRaw() *PineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *PineappleMock) Noo(_ context.Context) string {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() string); ok {
+		return _rf()
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *PineappleMock) OnNoo() *PineappleNooCall {
+	return &PineappleNooCall{Call: _m.Mock.On("Noo"), Parent: _m}
+}
+
+func (_m *PineappleMock) OnNooRaw() *PineappleNooCall {
+	return &PineappleNooCall{Call: _m.Mock.On("Noo"), Parent: _m}
+}
+
+type PineappleNooCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleNooCall) Panic(msg string) *PineappleNooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleNooCall) Once() *PineappleNooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleNooCall) Twice() *PineappleNooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleNooCall) Times(i int) *PineappleNooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleNooCall) WaitUntil(w <-chan time.Time) *PineappleNooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleNooCall) After(d time.Duration) *PineappleNooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleNooCall) Run(fn func(args mock.Arguments)) *PineappleNooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleNooCall) Maybe() *PineappleNooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleNooCall) TypedReturns(a string) *PineappleNooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *PineappleNooCall) ReturnsFn(fn func() string) *PineappleNooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleNooCall) TypedRun(fn func()) *PineappleNooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *PineappleNooCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleNooCall) OnGoo() *PineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleNooCall) OnHello(bar Water) *PineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleNooCall) OnNoo() *PineappleNooCall {
+	return _c.Parent.OnNoo()
+}
+
+func (_c *PineappleNooCall) OnWorld() *PineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleNooCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleNooCall) OnGooRaw() *PineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleNooCall) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleNooCall) OnNooRaw() *PineappleNooCall {
+	return _c.Parent.OnNooRaw()
+}
+
+func (_c *PineappleNooCall) OnWorldRaw() *PineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *PineappleMock) World() string {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() string); ok {
+		return _rf()
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *PineappleMock) OnWorld() *PineappleWorldCall {
+	return &PineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m}
+}
+
+func (_m *PineappleMock) OnWorldRaw() *PineappleWorldCall {
+	return &PineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m}
+}
+
+type PineappleWorldCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleWorldCall) Panic(msg string) *PineappleWorldCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleWorldCall) Once() *PineappleWorldCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleWorldCall) Twice() *PineappleWorldCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleWorldCall) Times(i int) *PineappleWorldCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleWorldCall) WaitUntil(w <-chan time.Time) *PineappleWorldCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleWorldCall) After(d time.Duration) *PineappleWorldCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleWorldCall) Run(fn func(args mock.Arguments)) *PineappleWorldCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleWorldCall) Maybe() *PineappleWorldCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleWorldCall) TypedReturns(a string) *PineappleWorldCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *PineappleWorldCall) ReturnsFn(fn func() string) *PineappleWorldCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleWorldCall) TypedRun(fn func()) *PineappleWorldCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *PineappleWorldCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleWorldCall) OnGoo() *PineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleWorldCall) OnHello(bar Water) *PineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleWorldCall) OnNoo() *PineappleNooCall {
+	return _c.Parent.OnNoo()
+}
+
+func (_c *PineappleWorldCall) OnWorld() *PineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleWorldCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleWorldCall) OnGooRaw() *PineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleWorldCall) OnHelloRaw(bar interface{}) *PineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleWorldCall) OnNooRaw() *PineappleNooCall {
+	return _c.Parent.OnNooRaw()
+}
+
+func (_c *PineappleWorldCall) OnWorldRaw() *PineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+// CoconutMock mock of Coconut.
+type CoconutMock struct{ mock.Mock }
+
+// NewCoconutMock creates a new CoconutMock.
+func NewCoconutMock(tb testing.TB) *CoconutMock {
+	tb.Helper()
+
+	m := &CoconutMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *CoconutMock) Boo(src *bytes.Buffer) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(*bytes.Buffer) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return &CoconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m}
+}
+
+func (_m *CoconutMock) OnBooRaw(src interface{}) *CoconutBooCall {
+	return &CoconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m}
+}
+
+type CoconutBooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutBooCall) Panic(msg string) *CoconutBooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutBooCall) Once() *CoconutBooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutBooCall) Twice() *CoconutBooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutBooCall) Times(i int) *CoconutBooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutBooCall) WaitUntil(w <-chan time.Time) *CoconutBooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutBooCall) After(d time.Duration) *CoconutBooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutBooCall) Run(fn func(args mock.Arguments)) *CoconutBooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutBooCall) Maybe() *CoconutBooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutBooCall) TypedReturns(a time.Duration) *CoconutBooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutBooCall) ReturnsFn(fn func(*bytes.Buffer) time.Duration) *CoconutBooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutBooCall) TypedRun(fn func(*bytes.Buffer)) *CoconutBooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(*bytes.Buffer)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *CoconutBooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutBooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutBooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutBooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutBooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutBooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutBooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutBooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutBooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutBooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutBooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutBooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutBooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutBooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutBooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutBooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutBooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutBooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutBooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutBooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutBooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutBooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutBooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutBooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutBooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutBooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Doo(src time.Duration) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(time.Duration) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnDoo(src time.Duration) *CoconutDooCall {
+	return &CoconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m}
+}
+
+func (_m *CoconutMock) OnDooRaw(src interface{}) *CoconutDooCall {
+	return &CoconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m}
+}
+
+type CoconutDooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutDooCall) Panic(msg string) *CoconutDooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutDooCall) Once() *CoconutDooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutDooCall) Twice() *CoconutDooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutDooCall) Times(i int) *CoconutDooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutDooCall) WaitUntil(w <-chan time.Time) *CoconutDooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutDooCall) After(d time.Duration) *CoconutDooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutDooCall) Run(fn func(args mock.Arguments)) *CoconutDooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutDooCall) Maybe() *CoconutDooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutDooCall) TypedReturns(a time.Duration) *CoconutDooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutDooCall) ReturnsFn(fn func(time.Duration) time.Duration) *CoconutDooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutDooCall) TypedRun(fn func(time.Duration)) *CoconutDooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(time.Duration)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *CoconutDooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutDooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutDooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutDooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutDooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutDooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutDooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutDooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutDooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutDooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutDooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutDooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutDooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutDooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutDooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutDooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutDooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutDooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutDooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutDooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutDooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutDooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutDooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutDooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutDooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutDooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Foo(st Strawberry) string {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(Strawberry) string); ok {
+		return _rf(st)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnFoo(st Strawberry) *CoconutFooCall {
+	return &CoconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m}
+}
+
+func (_m *CoconutMock) OnFooRaw(st interface{}) *CoconutFooCall {
+	return &CoconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m}
+}
+
+type CoconutFooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutFooCall) Panic(msg string) *CoconutFooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutFooCall) Once() *CoconutFooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutFooCall) Twice() *CoconutFooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutFooCall) Times(i int) *CoconutFooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutFooCall) WaitUntil(w <-chan time.Time) *CoconutFooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutFooCall) After(d time.Duration) *CoconutFooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutFooCall) Run(fn func(args mock.Arguments)) *CoconutFooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutFooCall) Maybe() *CoconutFooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutFooCall) TypedReturns(a string) *CoconutFooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutFooCall) ReturnsFn(fn func(Strawberry) string) *CoconutFooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutFooCall) TypedRun(fn func(Strawberry)) *CoconutFooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st, _ := args.Get(0).(Strawberry)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *CoconutFooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutFooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutFooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutFooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutFooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutFooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutFooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutFooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutFooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutFooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutFooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutFooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutFooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutFooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutFooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutFooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutFooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutFooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutFooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutFooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutFooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutFooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutFooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutFooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutFooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutFooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Goo(st string) Strawberry {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(string) Strawberry); ok {
+		return _rf(st)
+	}
+
+	_ra0, _ := _ret.Get(0).(Strawberry)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnGoo(st string) *CoconutGooCall {
+	return &CoconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m}
+}
+
+func (_m *CoconutMock) OnGooRaw(st interface{}) *CoconutGooCall {
+	return &CoconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m}
+}
+
+type CoconutGooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutGooCall) Panic(msg string) *CoconutGooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutGooCall) Once() *CoconutGooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutGooCall) Twice() *CoconutGooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutGooCall) Times(i int) *CoconutGooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutGooCall) WaitUntil(w <-chan time.Time) *CoconutGooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutGooCall) After(d time.Duration) *CoconutGooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutGooCall) Run(fn func(args mock.Arguments)) *CoconutGooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutGooCall) Maybe() *CoconutGooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutGooCall) TypedReturns(a Strawberry) *CoconutGooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutGooCall) ReturnsFn(fn func(string) Strawberry) *CoconutGooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutGooCall) TypedRun(fn func(string)) *CoconutGooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *CoconutGooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutGooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutGooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutGooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutGooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutGooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutGooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutGooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutGooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutGooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutGooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutGooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutGooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutGooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutGooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutGooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutGooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutGooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutGooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutGooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutGooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutGooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutGooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutGooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutGooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutGooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Hoo(aParam string, bParam int, cParam Water) {
+	_m.Called(aParam, bParam, cParam)
+}
+
+func (_m *CoconutMock) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return &CoconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m}
+}
+
+func (_m *CoconutMock) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return &CoconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m}
+}
+
+type CoconutHooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutHooCall) Panic(msg string) *CoconutHooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutHooCall) Once() *CoconutHooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutHooCall) Twice() *CoconutHooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutHooCall) Times(i int) *CoconutHooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutHooCall) WaitUntil(w <-chan time.Time) *CoconutHooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutHooCall) After(d time.Duration) *CoconutHooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutHooCall) Run(fn func(args mock.Arguments)) *CoconutHooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutHooCall) Maybe() *CoconutHooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutHooCall) TypedRun(fn func(string, int, Water)) *CoconutHooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		_bParam := args.Int(1)
+		_cParam, _ := args.Get(2).(Water)
+		fn(_aParam, _bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *CoconutHooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutHooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutHooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutHooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutHooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutHooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutHooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutHooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutHooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutHooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutHooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutHooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutHooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutHooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutHooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutHooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutHooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutHooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutHooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutHooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutHooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutHooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutHooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutHooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutHooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutHooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Joo(aParam string, bParam int, cParam Water) (string, int) {
+	_ret := _m.Called(aParam, bParam, cParam)
+
+	if _rf, ok := _ret.Get(0).(func(string, int, Water) (string, int)); ok {
+		return _rf(aParam, bParam, cParam)
+	}
+
+	_ra0 := _ret.String(0)
+	_rb1 := _ret.Int(1)
+
+	return _ra0, _rb1
+}
+
+func (_m *CoconutMock) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return &CoconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m}
+}
+
+func (_m *CoconutMock) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return &CoconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m}
+}
+
+type CoconutJooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutJooCall) Panic(msg string) *CoconutJooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutJooCall) Once() *CoconutJooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutJooCall) Twice() *CoconutJooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutJooCall) Times(i int) *CoconutJooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutJooCall) WaitUntil(w <-chan time.Time) *CoconutJooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutJooCall) After(d time.Duration) *CoconutJooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutJooCall) Run(fn func(args mock.Arguments)) *CoconutJooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutJooCall) Maybe() *CoconutJooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutJooCall) TypedReturns(a string, b int) *CoconutJooCall {
+	_c.Call = _c.Return(a, b)
+	return _c
+}
+
+func (_c *CoconutJooCall) ReturnsFn(fn func(string, int, Water) (string, int)) *CoconutJooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutJooCall) TypedRun(fn func(string, int, Water)) *CoconutJooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		_bParam := args.Int(1)
+		_cParam, _ := args.Get(2).(Water)
+		fn(_aParam, _bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *CoconutJooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutJooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutJooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutJooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutJooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutJooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutJooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutJooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutJooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutJooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutJooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutJooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutJooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutJooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutJooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutJooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutJooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutJooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutJooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutJooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutJooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutJooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutJooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutJooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutJooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutJooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Koo(src string) string {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(string) string); ok {
+		return _rf(src)
+	}
+
+	dst := _ret.String(0)
+
+	return dst
+}
+
+func (_m *CoconutMock) OnKoo(src string) *CoconutKooCall {
+	return &CoconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m}
+}
+
+func (_m *CoconutMock) OnKooRaw(src interface{}) *CoconutKooCall {
+	return &CoconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m}
+}
+
+type CoconutKooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutKooCall) Panic(msg string) *CoconutKooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutKooCall) Once() *CoconutKooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutKooCall) Twice() *CoconutKooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutKooCall) Times(i int) *CoconutKooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutKooCall) WaitUntil(w <-chan time.Time) *CoconutKooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutKooCall) After(d time.Duration) *CoconutKooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutKooCall) Run(fn func(args mock.Arguments)) *CoconutKooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutKooCall) Maybe() *CoconutKooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutKooCall) TypedReturns(a string) *CoconutKooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutKooCall) ReturnsFn(fn func(string) string) *CoconutKooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutKooCall) TypedRun(fn func(string)) *CoconutKooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src := args.String(0)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *CoconutKooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutKooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutKooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutKooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutKooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutKooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutKooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutKooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutKooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutKooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutKooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutKooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutKooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutKooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutKooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutKooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutKooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutKooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutKooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutKooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutKooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutKooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutKooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutKooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutKooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutKooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Loo(st string, values ...int) string {
+	_ret := _m.Called(st, values)
+
+	if _rf, ok := _ret.Get(0).(func(string, ...int) string); ok {
+		return _rf(st, values...)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnLoo(st string, values ...int) *CoconutLooCall {
+	return &CoconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m}
+}
+
+func (_m *CoconutMock) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return &CoconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m}
+}
+
+type CoconutLooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutLooCall) Panic(msg string) *CoconutLooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutLooCall) Once() *CoconutLooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutLooCall) Twice() *CoconutLooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutLooCall) Times(i int) *CoconutLooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutLooCall) WaitUntil(w <-chan time.Time) *CoconutLooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutLooCall) After(d time.Duration) *CoconutLooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutLooCall) Run(fn func(args mock.Arguments)) *CoconutLooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutLooCall) Maybe() *CoconutLooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutLooCall) TypedReturns(a string) *CoconutLooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutLooCall) ReturnsFn(fn func(string, ...int) string) *CoconutLooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutLooCall) TypedRun(fn func(string, ...int)) *CoconutLooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		_values, _ := args.Get(1).([]int)
+		fn(_st, _values...)
+	})
+	return _c
+}
+
+func (_c *CoconutLooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutLooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutLooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutLooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutLooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutLooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutLooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutLooCall) OnLoo(st string, values ...int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutLooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutLooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutLooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutLooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutLooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutLooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutLooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutLooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutLooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutLooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutLooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutLooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutLooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutLooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutLooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutLooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutLooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutLooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Moo(fn func(Strawberry, Strawberry) Pineapple) string {
+	_ret := _m.Called(fn)
+
+	if _rf, ok := _ret.Get(0).(func(func(Strawberry, Strawberry) Pineapple) string); ok {
+		return _rf(fn)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return &CoconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m}
+}
+
+func (_m *CoconutMock) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return &CoconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m}
+}
+
+type CoconutMooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutMooCall) Panic(msg string) *CoconutMooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutMooCall) Once() *CoconutMooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutMooCall) Twice() *CoconutMooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutMooCall) Times(i int) *CoconutMooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutMooCall) WaitUntil(w <-chan time.Time) *CoconutMooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutMooCall) After(d time.Duration) *CoconutMooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutMooCall) Run(fn func(args mock.Arguments)) *CoconutMooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutMooCall) Maybe() *CoconutMooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutMooCall) TypedReturns(a string) *CoconutMooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutMooCall) ReturnsFn(fn func(func(Strawberry, Strawberry) Pineapple) string) *CoconutMooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutMooCall) TypedRun(fn func(func(Strawberry, Strawberry) Pineapple)) *CoconutMooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_fn, _ := args.Get(0).(func(Strawberry, Strawberry) Pineapple)
+		fn(_fn)
+	})
+	return _c
+}
+
+func (_c *CoconutMooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutMooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutMooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutMooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutMooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutMooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutMooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutMooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutMooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutMooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutMooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutMooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutMooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutMooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutMooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutMooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutMooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutMooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutMooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutMooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutMooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutMooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutMooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutMooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutMooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutMooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Too(src string) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(string) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnToo(src string) *CoconutTooCall {
+	return &CoconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m}
+}
+
+func (_m *CoconutMock) OnTooRaw(src interface{}) *CoconutTooCall {
+	return &CoconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m}
+}
+
+type CoconutTooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutTooCall) Panic(msg string) *CoconutTooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutTooCall) Once() *CoconutTooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutTooCall) Twice() *CoconutTooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutTooCall) Times(i int) *CoconutTooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutTooCall) WaitUntil(w <-chan time.Time) *CoconutTooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutTooCall) After(d time.Duration) *CoconutTooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutTooCall) Run(fn func(args mock.Arguments)) *CoconutTooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutTooCall) Maybe() *CoconutTooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutTooCall) TypedReturns(a time.Duration) *CoconutTooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutTooCall) ReturnsFn(fn func(string) time.Duration) *CoconutTooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutTooCall) TypedRun(fn func(string)) *CoconutTooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src := args.String(0)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *CoconutTooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutTooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutTooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutTooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutTooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutTooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutTooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutTooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutTooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutTooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutTooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutTooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutTooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutTooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutTooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutTooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutTooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutTooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutTooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutTooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutTooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutTooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutTooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutTooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutTooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutTooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Voo(src *module.Version) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(*module.Version) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnVoo(src *module.Version) *CoconutVooCall {
+	return &CoconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m}
+}
+
+func (_m *CoconutMock) OnVooRaw(src interface{}) *CoconutVooCall {
+	return &CoconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m}
+}
+
+type CoconutVooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutVooCall) Panic(msg string) *CoconutVooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutVooCall) Once() *CoconutVooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutVooCall) Twice() *CoconutVooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutVooCall) Times(i int) *CoconutVooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutVooCall) WaitUntil(w <-chan time.Time) *CoconutVooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutVooCall) After(d time.Duration) *CoconutVooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutVooCall) Run(fn func(args mock.Arguments)) *CoconutVooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutVooCall) Maybe() *CoconutVooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutVooCall) TypedReturns(a time.Duration) *CoconutVooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutVooCall) ReturnsFn(fn func(*module.Version) time.Duration) *CoconutVooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutVooCall) TypedRun(fn func(*module.Version)) *CoconutVooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(*module.Version)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *CoconutVooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutVooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutVooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutVooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutVooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutVooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutVooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutVooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutVooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutVooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutVooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutVooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutVooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutVooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutVooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutVooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutVooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutVooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutVooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutVooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutVooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutVooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutVooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutVooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutVooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutVooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Yoo(st string) interface{} {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(string) interface{}); ok {
+		return _rf(st)
+	}
+
+	_ra0, _ := _ret.Get(0).(interface{})
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnYoo(st string) *CoconutYooCall {
+	return &CoconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m}
+}
+
+func (_m *CoconutMock) OnYooRaw(st interface{}) *CoconutYooCall {
+	return &CoconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m}
+}
+
+type CoconutYooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutYooCall) Panic(msg string) *CoconutYooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutYooCall) Once() *CoconutYooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutYooCall) Twice() *CoconutYooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutYooCall) Times(i int) *CoconutYooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutYooCall) WaitUntil(w <-chan time.Time) *CoconutYooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutYooCall) After(d time.Duration) *CoconutYooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutYooCall) Run(fn func(args mock.Arguments)) *CoconutYooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutYooCall) Maybe() *CoconutYooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutYooCall) TypedReturns(a interface{}) *CoconutYooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutYooCall) ReturnsFn(fn func(string) interface{}) *CoconutYooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutYooCall) TypedRun(fn func(string)) *CoconutYooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *CoconutYooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutYooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutYooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutYooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutYooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutYooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutYooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutYooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutYooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutYooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutYooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutYooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutYooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutYooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutYooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutYooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutYooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutYooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutYooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutYooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutYooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutYooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutYooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutYooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutYooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutYooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *CoconutMock) Zoo(st interface{}) string {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(interface{}) string); ok {
+		return _rf(st)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *CoconutMock) OnZoo(st interface{}) *CoconutZooCall {
+	return &CoconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m}
+}
+
+func (_m *CoconutMock) OnZooRaw(st interface{}) *CoconutZooCall {
+	return &CoconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m}
+}
+
+type CoconutZooCall struct {
+	*mock.Call
+	Parent *CoconutMock
+}
+
+func (_c *CoconutZooCall) Panic(msg string) *CoconutZooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CoconutZooCall) Once() *CoconutZooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CoconutZooCall) Twice() *CoconutZooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CoconutZooCall) Times(i int) *CoconutZooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CoconutZooCall) WaitUntil(w <-chan time.Time) *CoconutZooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CoconutZooCall) After(d time.Duration) *CoconutZooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CoconutZooCall) Run(fn func(args mock.Arguments)) *CoconutZooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CoconutZooCall) Maybe() *CoconutZooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CoconutZooCall) TypedReturns(a string) *CoconutZooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CoconutZooCall) ReturnsFn(fn func(interface{}) string) *CoconutZooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CoconutZooCall) TypedRun(fn func(interface{})) *CoconutZooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st, _ := args.Get(0).(interface{})
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *CoconutZooCall) OnBoo(src *bytes.Buffer) *CoconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *CoconutZooCall) OnDoo(src time.Duration) *CoconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *CoconutZooCall) OnFoo(st Strawberry) *CoconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *CoconutZooCall) OnGoo(st string) *CoconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *CoconutZooCall) OnHoo(aParam string, bParam int, cParam Water) *CoconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutZooCall) OnJoo(aParam string, bParam int, cParam Water) *CoconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *CoconutZooCall) OnKoo(src string) *CoconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *CoconutZooCall) OnLoo(st string, values []int) *CoconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *CoconutZooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *CoconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *CoconutZooCall) OnToo(src string) *CoconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *CoconutZooCall) OnVoo(src *module.Version) *CoconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *CoconutZooCall) OnYoo(st string) *CoconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *CoconutZooCall) OnZoo(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *CoconutZooCall) OnBooRaw(src interface{}) *CoconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *CoconutZooCall) OnDooRaw(src interface{}) *CoconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *CoconutZooCall) OnFooRaw(st interface{}) *CoconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *CoconutZooCall) OnGooRaw(st interface{}) *CoconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *CoconutZooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutZooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *CoconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *CoconutZooCall) OnKooRaw(src interface{}) *CoconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *CoconutZooCall) OnLooRaw(st interface{}, values interface{}) *CoconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *CoconutZooCall) OnMooRaw(fn interface{}) *CoconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *CoconutZooCall) OnTooRaw(src interface{}) *CoconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *CoconutZooCall) OnVooRaw(src interface{}) *CoconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *CoconutZooCall) OnYooRaw(st interface{}) *CoconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *CoconutZooCall) OnZooRaw(st interface{}) *CoconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+// CarrotMock mock of Carrot.
+type CarrotMock struct{ mock.Mock }
+
+// NewCarrotMock creates a new CarrotMock.
+func NewCarrotMock(tb testing.TB) *CarrotMock {
+	tb.Helper()
+
+	m := &CarrotMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *CarrotMock) Bar(aParam string) *b.Potato {
+	_ret := _m.Called(aParam)
+
+	if _rf, ok := _ret.Get(0).(func(string) *b.Potato); ok {
+		return _rf(aParam)
+	}
+
+	_ra0, _ := _ret.Get(0).(*b.Potato)
+
+	return _ra0
+}
+
+func (_m *CarrotMock) OnBar(aParam string) *CarrotBarCall {
+	return &CarrotBarCall{Call: _m.Mock.On("Bar", aParam), Parent: _m}
+}
+
+func (_m *CarrotMock) OnBarRaw(aParam interface{}) *CarrotBarCall {
+	return &CarrotBarCall{Call: _m.Mock.On("Bar", aParam), Parent: _m}
+}
+
+type CarrotBarCall struct {
+	*mock.Call
+	Parent *CarrotMock
+}
+
+func (_c *CarrotBarCall) Panic(msg string) *CarrotBarCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CarrotBarCall) Once() *CarrotBarCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CarrotBarCall) Twice() *CarrotBarCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CarrotBarCall) Times(i int) *CarrotBarCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CarrotBarCall) WaitUntil(w <-chan time.Time) *CarrotBarCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CarrotBarCall) After(d time.Duration) *CarrotBarCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CarrotBarCall) Run(fn func(args mock.Arguments)) *CarrotBarCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CarrotBarCall) Maybe() *CarrotBarCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CarrotBarCall) TypedReturns(a *b.Potato) *CarrotBarCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CarrotBarCall) ReturnsFn(fn func(string) *b.Potato) *CarrotBarCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CarrotBarCall) TypedRun(fn func(string)) *CarrotBarCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		fn(_aParam)
+	})
+	return _c
+}
+
+func (_c *CarrotBarCall) OnBar(aParam string) *CarrotBarCall {
+	return _c.Parent.OnBar(aParam)
+}
+
+func (_c *CarrotBarCall) OnBur(aParam string) *CarrotBurCall {
+	return _c.Parent.OnBur(aParam)
+}
+
+func (_c *CarrotBarCall) OnBarRaw(aParam interface{}) *CarrotBarCall {
+	return _c.Parent.OnBarRaw(aParam)
+}
+
+func (_c *CarrotBarCall) OnBurRaw(aParam interface{}) *CarrotBurCall {
+	return _c.Parent.OnBurRaw(aParam)
+}
+
+func (_m *CarrotMock) Bur(aParam string) *c.Cherry {
+	_ret := _m.Called(aParam)
+
+	if _rf, ok := _ret.Get(0).(func(string) *c.Cherry); ok {
+		return _rf(aParam)
+	}
+
+	_ra0, _ := _ret.Get(0).(*c.Cherry)
+
+	return _ra0
+}
+
+func (_m *CarrotMock) OnBur(aParam string) *CarrotBurCall {
+	return &CarrotBurCall{Call: _m.Mock.On("Bur", aParam), Parent: _m}
+}
+
+func (_m *CarrotMock) OnBurRaw(aParam interface{}) *CarrotBurCall {
+	return &CarrotBurCall{Call: _m.Mock.On("Bur", aParam), Parent: _m}
+}
+
+type CarrotBurCall struct {
+	*mock.Call
+	Parent *CarrotMock
+}
+
+func (_c *CarrotBurCall) Panic(msg string) *CarrotBurCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *CarrotBurCall) Once() *CarrotBurCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *CarrotBurCall) Twice() *CarrotBurCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *CarrotBurCall) Times(i int) *CarrotBurCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *CarrotBurCall) WaitUntil(w <-chan time.Time) *CarrotBurCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *CarrotBurCall) After(d time.Duration) *CarrotBurCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *CarrotBurCall) Run(fn func(args mock.Arguments)) *CarrotBurCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *CarrotBurCall) Maybe() *CarrotBurCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *CarrotBurCall) TypedReturns(a *c.Cherry) *CarrotBurCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *CarrotBurCall) ReturnsFn(fn func(string) *c.Cherry) *CarrotBurCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *CarrotBurCall) TypedRun(fn func(string)) *CarrotBurCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		fn(_aParam)
+	})
+	return _c
+}
+
+func (_c *CarrotBurCall) OnBar(aParam string) *CarrotBarCall {
+	return _c.Parent.OnBar(aParam)
+}
+
+func (_c *CarrotBurCall) OnBur(aParam string) *CarrotBurCall {
+	return _c.Parent.OnBur(aParam)
+}
+
+func (_c *CarrotBurCall) OnBarRaw(aParam interface{}) *CarrotBarCall {
+	return _c.Parent.OnBarRaw(aParam)
+}
+
+func (_c *CarrotBurCall) OnBurRaw(aParam interface{}) *CarrotBurCall {
+	return _c.Parent.OnBurRaw(aParam)
+}
+
+// OrangeMock mock of Orange.
+type OrangeMock struct{ mock.Mock }
+
+// NewOrangeMock creates a new OrangeMock.
+func NewOrangeMock(tb testing.TB) *OrangeMock {
+	tb.Helper()
+
+	m := &OrangeMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *OrangeMock) Juice() <-chan struct{} {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() <-chan struct{}); ok {
+		return _rf()
+	}
+
+	_ra0, _ := _ret.Get(0).(<-chan struct{})
+
+	return _ra0
+}
+
+func (_m *OrangeMock) OnJuice() *OrangeJuiceCall {
+	return &OrangeJuiceCall{Call: _m.Mock.On("Juice"), Parent: _m}
+}
+
+func (_m *OrangeMock) OnJuiceRaw() *OrangeJuiceCall {
+	return &OrangeJuiceCall{Call: _m.Mock.On("Juice"), Parent: _m}
+}
+
+type OrangeJuiceCall struct {
+	*mock.Call
+	Parent *OrangeMock
+}
+
+func (_c *OrangeJuiceCall) Panic(msg string) *OrangeJuiceCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) Once() *OrangeJuiceCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *OrangeJuiceCall) Twice() *OrangeJuiceCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *OrangeJuiceCall) Times(i int) *OrangeJuiceCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) WaitUntil(w <-chan time.Time) *OrangeJuiceCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) After(d time.Duration) *OrangeJuiceCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) Run(fn func(args mock.Arguments)) *OrangeJuiceCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) Maybe() *OrangeJuiceCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *OrangeJuiceCall) TypedReturns(a <-chan struct{}) *OrangeJuiceCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) ReturnsFn(fn func() <-chan struct{}) *OrangeJuiceCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *OrangeJuiceCall) TypedRun(fn func()) *OrangeJuiceCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *OrangeJuiceCall) OnJuice() *OrangeJuiceCall {
+	return _c.Parent.OnJuice()
+}
+
+func (_c *OrangeJuiceCall) OnJuiceRaw() *OrangeJuiceCall {
+	return _c.Parent.OnJuiceRaw()
+}
diff --git a/testdata/exported_types/a/mock_gen_test.go.golden b/testdata/exported_types/a/mock_gen_test.go.golden
new file mode 100644
index 0000000..4e3a79f
--- /dev/null
+++ b/testdata/exported_types/a/mock_gen_test.go.golden
@@ -0,0 +1,2923 @@
+// Code generated by mocktail; DO NOT EDIT.
+
+package c
+
+import (
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/mock"
+	"golang.org/x/mod/module"
+)
+
+// PineappleMock mock of Pineapple.
+type PineappleMock struct{ mock.Mock }
+
+// NewPineappleMock creates a new PineappleMock.
+func NewPineappleMock(tb testing.TB) *PineappleMock {
+	tb.Helper()
+
+	m := &PineappleMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *PineappleMock) Coo(_ context.Context, bParam string, cParam Water) Water {
+	_ret := _m.Called(bParam, cParam)
+
+	if _rf, ok := _ret.Get(0).(func(string, Water) Water); ok {
+		return _rf(bParam, cParam)
+	}
+
+	_ra0, _ := _ret.Get(0).(Water)
+
+	return _ra0
+}
+
+func (_m *PineappleMock) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return &PineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m}
+}
+
+func (_m *PineappleMock) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return &PineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m}
+}
+
+type PineappleCooCall struct {
+	*mock.Call
+	Parent *PineappleMock
+}
+
+func (_c *PineappleCooCall) Panic(msg string) *PineappleCooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *PineappleCooCall) Once() *PineappleCooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *PineappleCooCall) Twice() *PineappleCooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *PineappleCooCall) Times(i int) *PineappleCooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *PineappleCooCall) WaitUntil(w <-chan time.Time) *PineappleCooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *PineappleCooCall) After(d time.Duration) *PineappleCooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *PineappleCooCall) Run(fn func(args mock.Arguments)) *PineappleCooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *PineappleCooCall) Maybe() *PineappleCooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *PineappleCooCall) TypedReturns(a Water) *PineappleCooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *PineappleCooCall) ReturnsFn(fn func(string, Water) Water) *PineappleCooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *PineappleCooCall) TypedRun(fn func(string, Water)) *PineappleCooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_bParam := args.String(0)
+		_cParam, _ := args.Get(1).(Water)
+		fn(_bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *PineappleCooCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *PineappleCooCall) OnGoo() *pineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *PineappleCooCall) OnHello(bar Water) *pineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *PineappleCooCall) OnWorld() *pineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *PineappleCooCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *PineappleCooCall) OnGooRaw() *pineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *PineappleCooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *PineappleCooCall) OnWorldRaw() *pineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *pineappleMock) Goo() (string, int, Water) {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() (string, int, Water)); ok {
+		return _rf()
+	}
+
+	_ra0 := _ret.String(0)
+	_rb1 := _ret.Int(1)
+	_rc2, _ := _ret.Get(2).(Water)
+
+	return _ra0, _rb1, _rc2
+}
+
+func (_m *pineappleMock) OnGoo() *pineappleGooCall {
+	return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m}
+}
+
+func (_m *pineappleMock) OnGooRaw() *pineappleGooCall {
+	return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m}
+}
+
+type pineappleGooCall struct {
+	*mock.Call
+	Parent *pineappleMock
+}
+
+func (_c *pineappleGooCall) Panic(msg string) *pineappleGooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *pineappleGooCall) Once() *pineappleGooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *pineappleGooCall) Twice() *pineappleGooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *pineappleGooCall) Times(i int) *pineappleGooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *pineappleGooCall) WaitUntil(w <-chan time.Time) *pineappleGooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *pineappleGooCall) After(d time.Duration) *pineappleGooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *pineappleGooCall) Run(fn func(args mock.Arguments)) *pineappleGooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *pineappleGooCall) Maybe() *pineappleGooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *pineappleGooCall) TypedReturns(a string, b int, c Water) *pineappleGooCall {
+	_c.Call = _c.Return(a, b, c)
+	return _c
+}
+
+func (_c *pineappleGooCall) ReturnsFn(fn func() (string, int, Water)) *pineappleGooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *pineappleGooCall) TypedRun(fn func()) *pineappleGooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *pineappleGooCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *pineappleGooCall) OnGoo() *pineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *pineappleGooCall) OnHello(bar Water) *pineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *pineappleGooCall) OnWorld() *pineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *pineappleGooCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *pineappleGooCall) OnGooRaw() *pineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *pineappleGooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *pineappleGooCall) OnWorldRaw() *pineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *pineappleMock) Hello(bar Water) string {
+	_ret := _m.Called(bar)
+
+	if _rf, ok := _ret.Get(0).(func(Water) string); ok {
+		return _rf(bar)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *pineappleMock) OnHello(bar Water) *pineappleHelloCall {
+	return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m}
+}
+
+func (_m *pineappleMock) OnHelloRaw(bar interface{}) *pineappleHelloCall {
+	return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m}
+}
+
+type pineappleHelloCall struct {
+	*mock.Call
+	Parent *pineappleMock
+}
+
+func (_c *pineappleHelloCall) Panic(msg string) *pineappleHelloCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *pineappleHelloCall) Once() *pineappleHelloCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *pineappleHelloCall) Twice() *pineappleHelloCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *pineappleHelloCall) Times(i int) *pineappleHelloCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *pineappleHelloCall) WaitUntil(w <-chan time.Time) *pineappleHelloCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *pineappleHelloCall) After(d time.Duration) *pineappleHelloCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *pineappleHelloCall) Run(fn func(args mock.Arguments)) *pineappleHelloCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *pineappleHelloCall) Maybe() *pineappleHelloCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *pineappleHelloCall) TypedReturns(a string) *pineappleHelloCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *pineappleHelloCall) ReturnsFn(fn func(Water) string) *pineappleHelloCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *pineappleHelloCall) TypedRun(fn func(Water)) *pineappleHelloCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_bar, _ := args.Get(0).(Water)
+		fn(_bar)
+	})
+	return _c
+}
+
+func (_c *pineappleHelloCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *pineappleHelloCall) OnGoo() *pineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *pineappleHelloCall) OnHello(bar Water) *pineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *pineappleHelloCall) OnWorld() *pineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *pineappleHelloCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *pineappleHelloCall) OnGooRaw() *pineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *pineappleHelloCall) OnHelloRaw(bar interface{}) *pineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *pineappleHelloCall) OnWorldRaw() *pineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+func (_m *pineappleMock) World() string {
+	_ret := _m.Called()
+
+	if _rf, ok := _ret.Get(0).(func() string); ok {
+		return _rf()
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *pineappleMock) OnWorld() *pineappleWorldCall {
+	return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m}
+}
+
+func (_m *pineappleMock) OnWorldRaw() *pineappleWorldCall {
+	return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m}
+}
+
+type pineappleWorldCall struct {
+	*mock.Call
+	Parent *pineappleMock
+}
+
+func (_c *pineappleWorldCall) Panic(msg string) *pineappleWorldCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *pineappleWorldCall) Once() *pineappleWorldCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *pineappleWorldCall) Twice() *pineappleWorldCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *pineappleWorldCall) Times(i int) *pineappleWorldCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *pineappleWorldCall) WaitUntil(w <-chan time.Time) *pineappleWorldCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *pineappleWorldCall) After(d time.Duration) *pineappleWorldCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *pineappleWorldCall) Run(fn func(args mock.Arguments)) *pineappleWorldCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *pineappleWorldCall) Maybe() *pineappleWorldCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *pineappleWorldCall) TypedReturns(a string) *pineappleWorldCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *pineappleWorldCall) ReturnsFn(fn func() string) *pineappleWorldCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *pineappleWorldCall) TypedRun(fn func()) *pineappleWorldCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		fn()
+	})
+	return _c
+}
+
+func (_c *pineappleWorldCall) OnCoo(bParam string, cParam Water) *PineappleCooCall {
+	return _c.Parent.OnCoo(bParam, cParam)
+}
+
+func (_c *pineappleWorldCall) OnGoo() *pineappleGooCall {
+	return _c.Parent.OnGoo()
+}
+
+func (_c *pineappleWorldCall) OnHello(bar Water) *pineappleHelloCall {
+	return _c.Parent.OnHello(bar)
+}
+
+func (_c *pineappleWorldCall) OnWorld() *pineappleWorldCall {
+	return _c.Parent.OnWorld()
+}
+
+func (_c *pineappleWorldCall) OnCooRaw(bParam interface{}, cParam interface{}) *PineappleCooCall {
+	return _c.Parent.OnCooRaw(bParam, cParam)
+}
+
+func (_c *pineappleWorldCall) OnGooRaw() *pineappleGooCall {
+	return _c.Parent.OnGooRaw()
+}
+
+func (_c *pineappleWorldCall) OnHelloRaw(bar interface{}) *pineappleHelloCall {
+	return _c.Parent.OnHelloRaw(bar)
+}
+
+func (_c *pineappleWorldCall) OnWorldRaw() *pineappleWorldCall {
+	return _c.Parent.OnWorldRaw()
+}
+
+// coconutMock mock of Coconut.
+type coconutMock struct{ mock.Mock }
+
+// NewCoconutMock creates a new coconutMock.
+func NewCoconutMock(tb testing.TB) *coconutMock {
+	tb.Helper()
+
+	m := &coconutMock{}
+	m.Mock.Test(tb)
+
+	tb.Cleanup(func() { m.AssertExpectations(tb) })
+
+	return m
+}
+
+func (_m *coconutMock) Boo(src *bytes.Buffer) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(*bytes.Buffer) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m}
+}
+
+func (_m *coconutMock) OnBooRaw(src interface{}) *coconutBooCall {
+	return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m}
+}
+
+type coconutBooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutBooCall) Panic(msg string) *coconutBooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutBooCall) Once() *coconutBooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutBooCall) Twice() *coconutBooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutBooCall) Times(i int) *coconutBooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutBooCall) WaitUntil(w <-chan time.Time) *coconutBooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutBooCall) After(d time.Duration) *coconutBooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutBooCall) Run(fn func(args mock.Arguments)) *coconutBooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutBooCall) Maybe() *coconutBooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutBooCall) TypedReturns(a time.Duration) *coconutBooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutBooCall) ReturnsFn(fn func(*bytes.Buffer) time.Duration) *coconutBooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutBooCall) TypedRun(fn func(*bytes.Buffer)) *coconutBooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(*bytes.Buffer)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *coconutBooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutBooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutBooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutBooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutBooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutBooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutBooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutBooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutBooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutBooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutBooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutBooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutBooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutBooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutBooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutBooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutBooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutBooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutBooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutBooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutBooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutBooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutBooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutBooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutBooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutBooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Doo(src time.Duration) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(time.Duration) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnDoo(src time.Duration) *coconutDooCall {
+	return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m}
+}
+
+func (_m *coconutMock) OnDooRaw(src interface{}) *coconutDooCall {
+	return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m}
+}
+
+type coconutDooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutDooCall) Panic(msg string) *coconutDooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutDooCall) Once() *coconutDooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutDooCall) Twice() *coconutDooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutDooCall) Times(i int) *coconutDooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutDooCall) WaitUntil(w <-chan time.Time) *coconutDooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutDooCall) After(d time.Duration) *coconutDooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutDooCall) Run(fn func(args mock.Arguments)) *coconutDooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutDooCall) Maybe() *coconutDooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutDooCall) TypedReturns(a time.Duration) *coconutDooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutDooCall) ReturnsFn(fn func(time.Duration) time.Duration) *coconutDooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutDooCall) TypedRun(fn func(time.Duration)) *coconutDooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(time.Duration)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *coconutDooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutDooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutDooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutDooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutDooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutDooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutDooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutDooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutDooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutDooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutDooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutDooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutDooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutDooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutDooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutDooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutDooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutDooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutDooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutDooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutDooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutDooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutDooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutDooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutDooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutDooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Foo(st Strawberry) string {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(Strawberry) string); ok {
+		return _rf(st)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnFoo(st Strawberry) *coconutFooCall {
+	return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m}
+}
+
+func (_m *coconutMock) OnFooRaw(st interface{}) *coconutFooCall {
+	return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m}
+}
+
+type coconutFooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutFooCall) Panic(msg string) *coconutFooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutFooCall) Once() *coconutFooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutFooCall) Twice() *coconutFooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutFooCall) Times(i int) *coconutFooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutFooCall) WaitUntil(w <-chan time.Time) *coconutFooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutFooCall) After(d time.Duration) *coconutFooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutFooCall) Run(fn func(args mock.Arguments)) *coconutFooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutFooCall) Maybe() *coconutFooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutFooCall) TypedReturns(a string) *coconutFooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutFooCall) ReturnsFn(fn func(Strawberry) string) *coconutFooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutFooCall) TypedRun(fn func(Strawberry)) *coconutFooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st, _ := args.Get(0).(Strawberry)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *coconutFooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutFooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutFooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutFooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutFooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutFooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutFooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutFooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutFooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutFooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutFooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutFooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutFooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutFooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutFooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutFooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutFooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutFooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutFooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutFooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutFooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutFooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutFooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutFooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutFooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutFooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Goo(st string) Strawberry {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(string) Strawberry); ok {
+		return _rf(st)
+	}
+
+	_ra0, _ := _ret.Get(0).(Strawberry)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnGoo(st string) *coconutGooCall {
+	return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m}
+}
+
+func (_m *coconutMock) OnGooRaw(st interface{}) *coconutGooCall {
+	return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m}
+}
+
+type coconutGooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutGooCall) Panic(msg string) *coconutGooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutGooCall) Once() *coconutGooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutGooCall) Twice() *coconutGooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutGooCall) Times(i int) *coconutGooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutGooCall) WaitUntil(w <-chan time.Time) *coconutGooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutGooCall) After(d time.Duration) *coconutGooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutGooCall) Run(fn func(args mock.Arguments)) *coconutGooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutGooCall) Maybe() *coconutGooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutGooCall) TypedReturns(a Strawberry) *coconutGooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutGooCall) ReturnsFn(fn func(string) Strawberry) *coconutGooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutGooCall) TypedRun(fn func(string)) *coconutGooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *coconutGooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutGooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutGooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutGooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutGooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutGooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutGooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutGooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutGooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutGooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutGooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutGooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutGooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutGooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutGooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutGooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutGooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutGooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutGooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutGooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutGooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutGooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutGooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutGooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutGooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutGooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Hoo(aParam string, bParam int, cParam Water) {
+	_m.Called(aParam, bParam, cParam)
+}
+
+func (_m *coconutMock) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m}
+}
+
+func (_m *coconutMock) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m}
+}
+
+type coconutHooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutHooCall) Panic(msg string) *coconutHooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutHooCall) Once() *coconutHooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutHooCall) Twice() *coconutHooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutHooCall) Times(i int) *coconutHooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutHooCall) WaitUntil(w <-chan time.Time) *coconutHooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutHooCall) After(d time.Duration) *coconutHooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutHooCall) Run(fn func(args mock.Arguments)) *coconutHooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutHooCall) Maybe() *coconutHooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutHooCall) TypedRun(fn func(string, int, Water)) *coconutHooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		_bParam := args.Int(1)
+		_cParam, _ := args.Get(2).(Water)
+		fn(_aParam, _bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *coconutHooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutHooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutHooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutHooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutHooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutHooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutHooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutHooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutHooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutHooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutHooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutHooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutHooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutHooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutHooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutHooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutHooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutHooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutHooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutHooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutHooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutHooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutHooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutHooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutHooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutHooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Joo(aParam string, bParam int, cParam Water) (string, int) {
+	_ret := _m.Called(aParam, bParam, cParam)
+
+	if _rf, ok := _ret.Get(0).(func(string, int, Water) (string, int)); ok {
+		return _rf(aParam, bParam, cParam)
+	}
+
+	_ra0 := _ret.String(0)
+	_rb1 := _ret.Int(1)
+
+	return _ra0, _rb1
+}
+
+func (_m *coconutMock) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m}
+}
+
+func (_m *coconutMock) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m}
+}
+
+type coconutJooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutJooCall) Panic(msg string) *coconutJooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutJooCall) Once() *coconutJooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutJooCall) Twice() *coconutJooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutJooCall) Times(i int) *coconutJooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutJooCall) WaitUntil(w <-chan time.Time) *coconutJooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutJooCall) After(d time.Duration) *coconutJooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutJooCall) Run(fn func(args mock.Arguments)) *coconutJooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutJooCall) Maybe() *coconutJooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutJooCall) TypedReturns(a string, b int) *coconutJooCall {
+	_c.Call = _c.Return(a, b)
+	return _c
+}
+
+func (_c *coconutJooCall) ReturnsFn(fn func(string, int, Water) (string, int)) *coconutJooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutJooCall) TypedRun(fn func(string, int, Water)) *coconutJooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_aParam := args.String(0)
+		_bParam := args.Int(1)
+		_cParam, _ := args.Get(2).(Water)
+		fn(_aParam, _bParam, _cParam)
+	})
+	return _c
+}
+
+func (_c *coconutJooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutJooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutJooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutJooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutJooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutJooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutJooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutJooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutJooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutJooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutJooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutJooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutJooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutJooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutJooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutJooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutJooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutJooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutJooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutJooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutJooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutJooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutJooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutJooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutJooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutJooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Koo(src string) string {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(string) string); ok {
+		return _rf(src)
+	}
+
+	dst := _ret.String(0)
+
+	return dst
+}
+
+func (_m *coconutMock) OnKoo(src string) *coconutKooCall {
+	return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m}
+}
+
+func (_m *coconutMock) OnKooRaw(src interface{}) *coconutKooCall {
+	return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m}
+}
+
+type coconutKooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutKooCall) Panic(msg string) *coconutKooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutKooCall) Once() *coconutKooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutKooCall) Twice() *coconutKooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutKooCall) Times(i int) *coconutKooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutKooCall) WaitUntil(w <-chan time.Time) *coconutKooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutKooCall) After(d time.Duration) *coconutKooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutKooCall) Run(fn func(args mock.Arguments)) *coconutKooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutKooCall) Maybe() *coconutKooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutKooCall) TypedReturns(a string) *coconutKooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutKooCall) ReturnsFn(fn func(string) string) *coconutKooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutKooCall) TypedRun(fn func(string)) *coconutKooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src := args.String(0)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *coconutKooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutKooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutKooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutKooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutKooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutKooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutKooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutKooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutKooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutKooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutKooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutKooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutKooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutKooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutKooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutKooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutKooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutKooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutKooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutKooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutKooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutKooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutKooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutKooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutKooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutKooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Loo(st string, values ...int) string {
+	_ret := _m.Called(st, values)
+
+	if _rf, ok := _ret.Get(0).(func(string, ...int) string); ok {
+		return _rf(st, values...)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnLoo(st string, values ...int) *coconutLooCall {
+	return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m}
+}
+
+func (_m *coconutMock) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m}
+}
+
+type coconutLooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutLooCall) Panic(msg string) *coconutLooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutLooCall) Once() *coconutLooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutLooCall) Twice() *coconutLooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutLooCall) Times(i int) *coconutLooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutLooCall) WaitUntil(w <-chan time.Time) *coconutLooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutLooCall) After(d time.Duration) *coconutLooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutLooCall) Run(fn func(args mock.Arguments)) *coconutLooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutLooCall) Maybe() *coconutLooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutLooCall) TypedReturns(a string) *coconutLooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutLooCall) ReturnsFn(fn func(string, ...int) string) *coconutLooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutLooCall) TypedRun(fn func(string, ...int)) *coconutLooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		_values, _ := args.Get(1).([]int)
+		fn(_st, _values...)
+	})
+	return _c
+}
+
+func (_c *coconutLooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutLooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutLooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutLooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutLooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutLooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutLooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutLooCall) OnLoo(st string, values ...int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutLooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutLooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutLooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutLooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutLooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutLooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutLooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutLooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutLooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutLooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutLooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutLooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutLooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutLooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutLooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutLooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutLooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutLooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Moo(fn func(Strawberry, Strawberry) Pineapple) string {
+	_ret := _m.Called(fn)
+
+	if _rf, ok := _ret.Get(0).(func(func(Strawberry, Strawberry) Pineapple) string); ok {
+		return _rf(fn)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m}
+}
+
+func (_m *coconutMock) OnMooRaw(fn interface{}) *coconutMooCall {
+	return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m}
+}
+
+type coconutMooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutMooCall) Panic(msg string) *coconutMooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutMooCall) Once() *coconutMooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutMooCall) Twice() *coconutMooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutMooCall) Times(i int) *coconutMooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutMooCall) WaitUntil(w <-chan time.Time) *coconutMooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutMooCall) After(d time.Duration) *coconutMooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutMooCall) Run(fn func(args mock.Arguments)) *coconutMooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutMooCall) Maybe() *coconutMooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutMooCall) TypedReturns(a string) *coconutMooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutMooCall) ReturnsFn(fn func(func(Strawberry, Strawberry) Pineapple) string) *coconutMooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutMooCall) TypedRun(fn func(func(Strawberry, Strawberry) Pineapple)) *coconutMooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_fn, _ := args.Get(0).(func(Strawberry, Strawberry) Pineapple)
+		fn(_fn)
+	})
+	return _c
+}
+
+func (_c *coconutMooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutMooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutMooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutMooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutMooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutMooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutMooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutMooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutMooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutMooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutMooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutMooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutMooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutMooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutMooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutMooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutMooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutMooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutMooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutMooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutMooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutMooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutMooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutMooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutMooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutMooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Too(src string) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(string) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnToo(src string) *coconutTooCall {
+	return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m}
+}
+
+func (_m *coconutMock) OnTooRaw(src interface{}) *coconutTooCall {
+	return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m}
+}
+
+type coconutTooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutTooCall) Panic(msg string) *coconutTooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutTooCall) Once() *coconutTooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutTooCall) Twice() *coconutTooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutTooCall) Times(i int) *coconutTooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutTooCall) WaitUntil(w <-chan time.Time) *coconutTooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutTooCall) After(d time.Duration) *coconutTooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutTooCall) Run(fn func(args mock.Arguments)) *coconutTooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutTooCall) Maybe() *coconutTooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutTooCall) TypedReturns(a time.Duration) *coconutTooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutTooCall) ReturnsFn(fn func(string) time.Duration) *coconutTooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutTooCall) TypedRun(fn func(string)) *coconutTooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src := args.String(0)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *coconutTooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutTooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutTooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutTooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutTooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutTooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutTooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutTooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutTooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutTooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutTooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutTooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutTooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutTooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutTooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutTooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutTooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutTooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutTooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutTooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutTooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutTooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutTooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutTooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutTooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutTooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Voo(src *module.Version) time.Duration {
+	_ret := _m.Called(src)
+
+	if _rf, ok := _ret.Get(0).(func(*module.Version) time.Duration); ok {
+		return _rf(src)
+	}
+
+	_ra0, _ := _ret.Get(0).(time.Duration)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnVoo(src *module.Version) *coconutVooCall {
+	return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m}
+}
+
+func (_m *coconutMock) OnVooRaw(src interface{}) *coconutVooCall {
+	return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m}
+}
+
+type coconutVooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutVooCall) Panic(msg string) *coconutVooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutVooCall) Once() *coconutVooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutVooCall) Twice() *coconutVooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutVooCall) Times(i int) *coconutVooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutVooCall) WaitUntil(w <-chan time.Time) *coconutVooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutVooCall) After(d time.Duration) *coconutVooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutVooCall) Run(fn func(args mock.Arguments)) *coconutVooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutVooCall) Maybe() *coconutVooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutVooCall) TypedReturns(a time.Duration) *coconutVooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutVooCall) ReturnsFn(fn func(*module.Version) time.Duration) *coconutVooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutVooCall) TypedRun(fn func(*module.Version)) *coconutVooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_src, _ := args.Get(0).(*module.Version)
+		fn(_src)
+	})
+	return _c
+}
+
+func (_c *coconutVooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutVooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutVooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutVooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutVooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutVooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutVooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutVooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutVooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutVooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutVooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutVooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutVooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutVooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutVooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutVooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutVooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutVooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutVooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutVooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutVooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutVooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutVooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutVooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutVooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutVooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Yoo(st string) interface{} {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(string) interface{}); ok {
+		return _rf(st)
+	}
+
+	_ra0, _ := _ret.Get(0).(interface{})
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnYoo(st string) *coconutYooCall {
+	return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m}
+}
+
+func (_m *coconutMock) OnYooRaw(st interface{}) *coconutYooCall {
+	return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m}
+}
+
+type coconutYooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutYooCall) Panic(msg string) *coconutYooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutYooCall) Once() *coconutYooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutYooCall) Twice() *coconutYooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutYooCall) Times(i int) *coconutYooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutYooCall) WaitUntil(w <-chan time.Time) *coconutYooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutYooCall) After(d time.Duration) *coconutYooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutYooCall) Run(fn func(args mock.Arguments)) *coconutYooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutYooCall) Maybe() *coconutYooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutYooCall) TypedReturns(a interface{}) *coconutYooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutYooCall) ReturnsFn(fn func(string) interface{}) *coconutYooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutYooCall) TypedRun(fn func(string)) *coconutYooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st := args.String(0)
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *coconutYooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutYooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutYooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutYooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutYooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutYooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutYooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutYooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutYooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutYooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutYooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutYooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutYooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutYooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutYooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutYooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutYooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutYooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutYooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutYooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutYooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutYooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutYooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutYooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutYooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutYooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
+
+func (_m *coconutMock) Zoo(st interface{}) string {
+	_ret := _m.Called(st)
+
+	if _rf, ok := _ret.Get(0).(func(interface{}) string); ok {
+		return _rf(st)
+	}
+
+	_ra0 := _ret.String(0)
+
+	return _ra0
+}
+
+func (_m *coconutMock) OnZoo(st interface{}) *coconutZooCall {
+	return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m}
+}
+
+func (_m *coconutMock) OnZooRaw(st interface{}) *coconutZooCall {
+	return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m}
+}
+
+type coconutZooCall struct {
+	*mock.Call
+	Parent *coconutMock
+}
+
+func (_c *coconutZooCall) Panic(msg string) *coconutZooCall {
+	_c.Call = _c.Call.Panic(msg)
+	return _c
+}
+
+func (_c *coconutZooCall) Once() *coconutZooCall {
+	_c.Call = _c.Call.Once()
+	return _c
+}
+
+func (_c *coconutZooCall) Twice() *coconutZooCall {
+	_c.Call = _c.Call.Twice()
+	return _c
+}
+
+func (_c *coconutZooCall) Times(i int) *coconutZooCall {
+	_c.Call = _c.Call.Times(i)
+	return _c
+}
+
+func (_c *coconutZooCall) WaitUntil(w <-chan time.Time) *coconutZooCall {
+	_c.Call = _c.Call.WaitUntil(w)
+	return _c
+}
+
+func (_c *coconutZooCall) After(d time.Duration) *coconutZooCall {
+	_c.Call = _c.Call.After(d)
+	return _c
+}
+
+func (_c *coconutZooCall) Run(fn func(args mock.Arguments)) *coconutZooCall {
+	_c.Call = _c.Call.Run(fn)
+	return _c
+}
+
+func (_c *coconutZooCall) Maybe() *coconutZooCall {
+	_c.Call = _c.Call.Maybe()
+	return _c
+}
+
+func (_c *coconutZooCall) TypedReturns(a string) *coconutZooCall {
+	_c.Call = _c.Return(a)
+	return _c
+}
+
+func (_c *coconutZooCall) ReturnsFn(fn func(interface{}) string) *coconutZooCall {
+	_c.Call = _c.Return(fn)
+	return _c
+}
+
+func (_c *coconutZooCall) TypedRun(fn func(interface{})) *coconutZooCall {
+	_c.Call = _c.Call.Run(func(args mock.Arguments) {
+		_st, _ := args.Get(0).(interface{})
+		fn(_st)
+	})
+	return _c
+}
+
+func (_c *coconutZooCall) OnBoo(src *bytes.Buffer) *coconutBooCall {
+	return _c.Parent.OnBoo(src)
+}
+
+func (_c *coconutZooCall) OnDoo(src time.Duration) *coconutDooCall {
+	return _c.Parent.OnDoo(src)
+}
+
+func (_c *coconutZooCall) OnFoo(st Strawberry) *coconutFooCall {
+	return _c.Parent.OnFoo(st)
+}
+
+func (_c *coconutZooCall) OnGoo(st string) *coconutGooCall {
+	return _c.Parent.OnGoo(st)
+}
+
+func (_c *coconutZooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall {
+	return _c.Parent.OnHoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutZooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall {
+	return _c.Parent.OnJoo(aParam, bParam, cParam)
+}
+
+func (_c *coconutZooCall) OnKoo(src string) *coconutKooCall {
+	return _c.Parent.OnKoo(src)
+}
+
+func (_c *coconutZooCall) OnLoo(st string, values []int) *coconutLooCall {
+	return _c.Parent.OnLoo(st, values...)
+}
+
+func (_c *coconutZooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall {
+	return _c.Parent.OnMoo(fn)
+}
+
+func (_c *coconutZooCall) OnToo(src string) *coconutTooCall {
+	return _c.Parent.OnToo(src)
+}
+
+func (_c *coconutZooCall) OnVoo(src *module.Version) *coconutVooCall {
+	return _c.Parent.OnVoo(src)
+}
+
+func (_c *coconutZooCall) OnYoo(st string) *coconutYooCall {
+	return _c.Parent.OnYoo(st)
+}
+
+func (_c *coconutZooCall) OnZoo(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZoo(st)
+}
+
+func (_c *coconutZooCall) OnBooRaw(src interface{}) *coconutBooCall {
+	return _c.Parent.OnBooRaw(src)
+}
+
+func (_c *coconutZooCall) OnDooRaw(src interface{}) *coconutDooCall {
+	return _c.Parent.OnDooRaw(src)
+}
+
+func (_c *coconutZooCall) OnFooRaw(st interface{}) *coconutFooCall {
+	return _c.Parent.OnFooRaw(st)
+}
+
+func (_c *coconutZooCall) OnGooRaw(st interface{}) *coconutGooCall {
+	return _c.Parent.OnGooRaw(st)
+}
+
+func (_c *coconutZooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall {
+	return _c.Parent.OnHooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutZooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall {
+	return _c.Parent.OnJooRaw(aParam, bParam, cParam)
+}
+
+func (_c *coconutZooCall) OnKooRaw(src interface{}) *coconutKooCall {
+	return _c.Parent.OnKooRaw(src)
+}
+
+func (_c *coconutZooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall {
+	return _c.Parent.OnLooRaw(st, values)
+}
+
+func (_c *coconutZooCall) OnMooRaw(fn interface{}) *coconutMooCall {
+	return _c.Parent.OnMooRaw(fn)
+}
+
+func (_c *coconutZooCall) OnTooRaw(src interface{}) *coconutTooCall {
+	return _c.Parent.OnTooRaw(src)
+}
+
+func (_c *coconutZooCall) OnVooRaw(src interface{}) *coconutVooCall {
+	return _c.Parent.OnVooRaw(src)
+}
+
+func (_c *coconutZooCall) OnYooRaw(st interface{}) *coconutYooCall {
+	return _c.Parent.OnYooRaw(st)
+}
+
+func (_c *coconutZooCall) OnZooRaw(st interface{}) *coconutZooCall {
+	return _c.Parent.OnZooRaw(st)
+}
diff --git a/testdata/exported_types/a/mock_test.go b/testdata/exported_types/a/mock_test.go
new file mode 100644
index 0000000..2521d90
--- /dev/null
+++ b/testdata/exported_types/a/mock_test.go
@@ -0,0 +1,52 @@
+package a
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// mocktail:Pineapple
+// mocktail:Coconut
+// mocktail:b.Carrot
+// mocktail:Orange
+
+func TestName(t *testing.T) {
+	var s Pineapple = NewPineappleMock(t).
+		OnHello(Water{}).TypedReturns("a").Once().
+		OnWorld().TypedReturns("a").Once().
+		OnGoo().TypedReturns("", 1, Water{}).Once().
+		OnCoo("", Water{}).TypedReturns(Water{}).
+		TypedRun(func(s string, water Water) {}).Once().
+		Parent
+
+	s.Hello(Water{})
+	s.World()
+	s.Goo()
+	s.Coo(context.Background(), "", Water{})
+
+	fn := func(st Strawberry, stban Strawberry) Pineapple {
+		return s
+	}
+
+	var c Coconut = NewCoconutMock(t).
+		OnLoo("a", 1, 2).TypedReturns("foo").Once().
+		OnMoo(fn).TypedReturns("").Once().
+		Parent
+
+	c.Loo("a", 1, 2)
+	c.Moo(fn)
+
+	juiceCh := make(chan struct{}, 1)
+	juiceCh <- struct{}{}
+
+	var o Orange = NewOrangeMock(t).
+		OnJuice().TypedReturns(juiceCh).Once().
+		Parent
+
+	select {
+	case <-o.Juice():
+	case <-time.After(10 * time.Millisecond):
+		t.Fatalf("timed out waiting for an orange juice")
+	}
+}

From 8c14b83e976682bf560c3e3bfd1cb244a88f64ad Mon Sep 17 00:00:00 2001
From: Wytse Vellema <w.vellema@slash2.nl>
Date: Tue, 3 Oct 2023 17:06:13 +0200
Subject: [PATCH 2/2] Parse generic types correctly

The following generic data type was not parsed correctly:

    type Subscription[T any] struct {
	c chan T
    }

This was used in the following mocked interface:

    type Test interface {
        GetSubscription() *Subscription[SomeType]
    }

SubscribeUpdate(c chan CollectionEvent) *event.Subscription[CollectionEvent]
---
 syrup.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/syrup.go b/syrup.go
index e36d79d..71d1347 100644
--- a/syrup.go
+++ b/syrup.go
@@ -603,6 +603,26 @@ func (s Syrup) getTupleTypes(t *types.Tuple) []string {
 func (s Syrup) getNamedTypeName(t *types.Named) string {
 	name := t.String()
 
+	// Parse generic parameters.
+	if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
+		name = ""
+		// Add package name if it's not the same as the current package.
+		if t.Obj().Pkg().Path() != s.PkgPath {
+			name = t.Obj().Pkg().Name() + "."
+		}
+		name += t.Obj().Name()
+
+		// Add all type arguments.
+		typeArgs := make([]string, t.TypeArgs().Len())
+		for i := 0; i < t.TypeArgs().Len(); i++ {
+			typeArgs[i] = s.getTypeName(t.TypeArgs().At(i), false)
+		}
+
+		name += "[" + strings.Join(typeArgs, ",") + "]"
+
+		return name
+	}
+
 	i := strings.LastIndex(t.String(), "/")
 	if i > -1 {
 		name = name[i+1:]