From a041b163cd8fed4e8dc293d5fb9fffe8365e3c35 Mon Sep 17 00:00:00 2001
From: Ivan Feofanov <Ivan-Feofanov@users.noreply.github.com>
Date: Tue, 31 Jan 2023 13:20:05 +0400
Subject: [PATCH] feat: generate exported mocks with `-e` flag

---
 mocktail.go                              |   23 +-
 mocktail_test.go                         |   63 +-
 readme.md                                |   10 +
 syrup.go                                 |   13 +-
 testdata/exported/a/a.go                 |   43 +
 testdata/exported/a/b/b.go               |   14 +
 testdata/exported/a/c/c.go               |    5 +
 testdata/exported/a/go.mod               |   16 +
 testdata/exported/a/go.sum               |   20 +
 testdata/exported/a/mock_gen.go          | 3397 ++++++++++++++++++++++
 testdata/exported/a/mock_gen.go.golden   | 3397 ++++++++++++++++++++++
 testdata/exported/a/mock_test.go         |   55 +
 testdata/exported/b/b.go                 |    5 +
 testdata/exported/b/c/c.go               |   38 +
 testdata/exported/b/c/mock_gen.go        | 2923 +++++++++++++++++++
 testdata/exported/b/c/mock_gen.go.golden | 2923 +++++++++++++++++++
 testdata/exported/b/c/mock_test.go       |   38 +
 testdata/exported/b/go.mod               |   16 +
 testdata/exported/b/go.sum               |   20 +
 19 files changed, 13007 insertions(+), 12 deletions(-)
 create mode 100644 testdata/exported/a/a.go
 create mode 100644 testdata/exported/a/b/b.go
 create mode 100644 testdata/exported/a/c/c.go
 create mode 100644 testdata/exported/a/go.mod
 create mode 100644 testdata/exported/a/go.sum
 create mode 100644 testdata/exported/a/mock_gen.go
 create mode 100644 testdata/exported/a/mock_gen.go.golden
 create mode 100644 testdata/exported/a/mock_test.go
 create mode 100644 testdata/exported/b/b.go
 create mode 100644 testdata/exported/b/c/c.go
 create mode 100644 testdata/exported/b/c/mock_gen.go
 create mode 100644 testdata/exported/b/c/mock_gen.go.golden
 create mode 100644 testdata/exported/b/c/mock_test.go
 create mode 100644 testdata/exported/b/go.mod
 create mode 100644 testdata/exported/b/go.sum

diff --git a/mocktail.go b/mocktail.go
index a627689..b042a84 100644
--- a/mocktail.go
+++ b/mocktail.go
@@ -4,6 +4,7 @@ package main
 import (
 	"bufio"
 	"bytes"
+	"flag"
 	"fmt"
 	"go/format"
 	"go/importer"
@@ -18,8 +19,9 @@ import (
 )
 
 const (
-	srcMockFile    = "mock_test.go"
-	outputMockFile = "mock_gen_test.go"
+	srcMockFile            = "mock_test.go"
+	outputMockFile         = "mock_gen_test.go"
+	outputExportedMockFile = "mock_gen.go"
 )
 
 const contextType = "context.Context"
@@ -45,6 +47,10 @@ func main() {
 		log.Fatal("get module path", err)
 	}
 
+	var exported bool
+	flag.BoolVar(&exported, "e", false, "generate exported mocks")
+	flag.Parse()
+
 	root := info.Dir
 
 	err = os.Chdir(root)
@@ -61,7 +67,7 @@ func main() {
 		return
 	}
 
-	err = generate(model)
+	err = generate(model, exported)
 	if err != nil {
 		log.Fatalf("generate: %v", err)
 	}
@@ -233,7 +239,7 @@ func getTypeImports(t types.Type) []string {
 	}
 }
 
-func generate(model map[string]PackageDesc) error {
+func generate(model map[string]PackageDesc, exported bool) error {
 	for fp, pkgDesc := range model {
 		buffer := bytes.NewBufferString("")
 
@@ -243,7 +249,7 @@ func generate(model map[string]PackageDesc) error {
 		}
 
 		for _, interfaceDesc := range pkgDesc.Interfaces {
-			err = writeMockBase(buffer, interfaceDesc.Name)
+			err = writeMockBase(buffer, interfaceDesc.Name, exported)
 			if err != nil {
 				return err
 			}
@@ -279,7 +285,12 @@ func generate(model map[string]PackageDesc) error {
 			return fmt.Errorf("source: %w", err)
 		}
 
-		out := filepath.Join(filepath.Dir(fp), outputMockFile)
+		fileName := outputMockFile
+		if exported {
+			fileName = outputExportedMockFile
+		}
+
+		out := filepath.Join(filepath.Dir(fp), fileName)
 
 		log.Println(out)
 
diff --git a/mocktail_test.go b/mocktail_test.go
index ac288db..c6968bc 100644
--- a/mocktail_test.go
+++ b/mocktail_test.go
@@ -12,9 +12,9 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const testRoot = "./testdata/src"
-
 func TestMocktail(t *testing.T) {
+	const testRoot = "./testdata/src"
+
 	if runtime.GOOS == "windows" {
 		t.Skip(runtime.GOOS)
 	}
@@ -70,3 +70,62 @@ func TestMocktail(t *testing.T) {
 		require.NoError(t, err)
 	}
 }
+
+func TestMocktail_exported(t *testing.T) {
+	const testRoot = "./testdata/exported"
+
+	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").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 142139b..02fde4b 100644
--- a/readme.md
+++ b/readme.md
@@ -98,6 +98,16 @@ func TestMock(t *testing.T) {
 }
 ```
 
+## Exportable Mocks
+
+If you need to use your mocks in external packages just add flag `-e`:
+
+```shell
+mocktail -e
+```
+
+In this case, mock will be created in the same package but in the file `mock_gen.go`.
+
 <!--
 
 Replacement pattern:
diff --git a/syrup.go b/syrup.go
index afd0857..86717e8 100644
--- a/syrup.go
+++ b/syrup.go
@@ -27,8 +27,8 @@ package {{ .Name }}
 // {{ .InterfaceName | ToGoCamel }}Mock mock of {{ .InterfaceName }}.
 type {{ .InterfaceName | ToGoCamel }}Mock struct { mock.Mock }
 
-// new{{ .InterfaceName | ToGoPascal }}Mock creates a new {{ .InterfaceName | ToGoCamel }}Mock.
-func new{{ .InterfaceName | ToGoPascal }}Mock(tb testing.TB) *{{ .InterfaceName | ToGoCamel }}Mock {
+// {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock creates a new {{ .InterfaceName | ToGoCamel }}Mock.
+func {{.ConstructorPrefix}}{{ .InterfaceName | ToGoPascal }}Mock(tb testing.TB) *{{ .InterfaceName | ToGoCamel }}Mock {
 	tb.Helper()
 
 	m := &{{ .InterfaceName | ToGoCamel }}Mock{}
@@ -687,18 +687,23 @@ func writeImports(writer io.Writer, descPkg PackageDesc) error {
 	return tmpl.Execute(writer, data)
 }
 
-func writeMockBase(writer io.Writer, interfaceName string) error {
+func writeMockBase(writer io.Writer, interfaceName string, exported bool) error {
 	base := template.New("templateMockBase").Funcs(template.FuncMap{
 		"ToGoCamel":  strcase.ToGoCamel,
 		"ToGoPascal": strcase.ToGoPascal,
 	})
 
+	constructorPrefix := "new"
+	if exported {
+		constructorPrefix = "New"
+	}
+
 	tmpl, err := base.Parse(templateMockBase)
 	if err != nil {
 		return err
 	}
 
-	return tmpl.Execute(writer, map[string]string{"InterfaceName": interfaceName})
+	return tmpl.Execute(writer, map[string]interface{}{"InterfaceName": interfaceName, "ConstructorPrefix": constructorPrefix})
 }
 
 func quickGoImports(descPkg PackageDesc) []string {
diff --git a/testdata/exported/a/a.go b/testdata/exported/a/a.go
new file mode 100644
index 0000000..99c895e
--- /dev/null
+++ b/testdata/exported/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/a/b/b.go b/testdata/exported/a/b/b.go
new file mode 100644
index 0000000..1181d07
--- /dev/null
+++ b/testdata/exported/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/a/c/c.go b/testdata/exported/a/c/c.go
new file mode 100644
index 0000000..e4fed55
--- /dev/null
+++ b/testdata/exported/a/c/c.go
@@ -0,0 +1,5 @@
+package c
+
+type Cherry struct {
+	Name string
+}
diff --git a/testdata/exported/a/go.mod b/testdata/exported/a/go.mod
new file mode 100644
index 0000000..627f9ee
--- /dev/null
+++ b/testdata/exported/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/a/go.sum b/testdata/exported/a/go.sum
new file mode 100644
index 0000000..0c98ef7
--- /dev/null
+++ b/testdata/exported/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/a/mock_gen.go b/testdata/exported/a/mock_gen.go
new file mode 100644
index 0000000..87ccce1
--- /dev/null
+++ b/testdata/exported/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/a/mock_gen.go.golden b/testdata/exported/a/mock_gen.go.golden
new file mode 100644
index 0000000..87ccce1
--- /dev/null
+++ b/testdata/exported/a/mock_gen.go.golden
@@ -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/a/mock_test.go b/testdata/exported/a/mock_test.go
new file mode 100644
index 0000000..28092b3
--- /dev/null
+++ b/testdata/exported/a/mock_test.go
@@ -0,0 +1,55 @@
+package a_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"a"
+)
+
+// mocktail:Pineapple
+// mocktail:Coconut
+// mocktail:b.Carrot
+// mocktail-:fmt.Stringer
+// mocktail:Orange
+
+func TestName(t *testing.T) {
+	var s a.Pineapple = a.NewPineappleMock(t).
+		OnHello(a.Water{}).TypedReturns("a").Once().
+		OnWorld().TypedReturns("a").Once().
+		OnGoo().TypedReturns("", 1, a.Water{}).Once().
+		OnCoo("", a.Water{}).TypedReturns(a.Water{}).
+		TypedRun(func(s string, water a.Water) {}).Once().
+		Parent
+
+	s.Hello(a.Water{})
+	s.World()
+	s.Goo()
+	s.Coo(context.Background(), "", a.Water{})
+
+	fn := func(st a.Strawberry, stban a.Strawberry) a.Pineapple {
+		return s
+	}
+
+	var c a.Coconut = a.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 a.Orange = a.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")
+	}
+}
diff --git a/testdata/exported/b/b.go b/testdata/exported/b/b.go
new file mode 100644
index 0000000..4736151
--- /dev/null
+++ b/testdata/exported/b/b.go
@@ -0,0 +1,5 @@
+package b
+
+func Hello() string {
+	return "hello"
+}
diff --git a/testdata/exported/b/c/c.go b/testdata/exported/b/c/c.go
new file mode 100644
index 0000000..adb8b9e
--- /dev/null
+++ b/testdata/exported/b/c/c.go
@@ -0,0 +1,38 @@
+package c
+
+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
+}
+
+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
+}
diff --git a/testdata/exported/b/c/mock_gen.go b/testdata/exported/b/c/mock_gen.go
new file mode 100644
index 0000000..e44f30b
--- /dev/null
+++ b/testdata/exported/b/c/mock_gen.go
@@ -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/b/c/mock_gen.go.golden b/testdata/exported/b/c/mock_gen.go.golden
new file mode 100644
index 0000000..e44f30b
--- /dev/null
+++ b/testdata/exported/b/c/mock_gen.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/b/c/mock_test.go b/testdata/exported/b/c/mock_test.go
new file mode 100644
index 0000000..23954c2
--- /dev/null
+++ b/testdata/exported/b/c/mock_test.go
@@ -0,0 +1,38 @@
+package c_test
+
+import (
+	"context"
+	"testing"
+
+	"b/c"
+)
+
+// mocktail:Pineapple
+// mocktail:Coconut
+
+func TestName(t *testing.T) {
+	var s c.Pineapple = c.NewPineappleMock(t).
+		OnHello(c.Water{}).TypedReturns("a").Once().
+		OnWorld().TypedReturns("a").Once().
+		OnGoo().TypedReturns("", 1, c.Water{}).Once().
+		OnCoo("", c.Water{}).TypedReturns(c.Water{}).
+		TypedRun(func(s string, water c.Water) {}).Once().
+		Parent
+
+	s.Hello(c.Water{})
+	s.World()
+	s.Goo()
+	s.Coo(context.Background(), "", c.Water{})
+
+	fn := func(st c.Strawberry, stban c.Strawberry) c.Pineapple {
+		return s
+	}
+
+	var coco c.Coconut = c.NewCoconutMock(t).
+		OnLoo("a", 1, 2).TypedReturns("foo").Once().
+		OnMoo(fn).TypedReturns("").Once().
+		Parent
+
+	coco.Loo("a", 1, 2)
+	coco.Moo(fn)
+}
diff --git a/testdata/exported/b/go.mod b/testdata/exported/b/go.mod
new file mode 100644
index 0000000..68e91a6
--- /dev/null
+++ b/testdata/exported/b/go.mod
@@ -0,0 +1,16 @@
+module b
+
+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/b/go.sum b/testdata/exported/b/go.sum
new file mode 100644
index 0000000..0c98ef7
--- /dev/null
+++ b/testdata/exported/b/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=