diff --git a/mocks/pkg/fixtures/A.go b/mocks/pkg/fixtures/A.go
index 246f7b9e..4d8a4419 100644
--- a/mocks/pkg/fixtures/A.go
+++ b/mocks/pkg/fixtures/A.go
@@ -33,13 +33,13 @@ func (_m *A) Call() (test.B, error) {
 	return r0, r1
 }
 
-type NewAT interface {
+type mockConstructorTestingTNewA interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewA creates a new instance of A. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewA(t NewAT) *A {
+func NewA(t mockConstructorTestingTNewA) *A {
 	mock := &A{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/AsyncProducer.go b/mocks/pkg/fixtures/AsyncProducer.go
index 623f9b7a..b8cc9453 100644
--- a/mocks/pkg/fixtures/AsyncProducer.go
+++ b/mocks/pkg/fixtures/AsyncProducer.go
@@ -57,13 +57,13 @@ func (_m *AsyncProducer) Whatever() chan bool {
 	return r0
 }
 
-type NewAsyncProducerT interface {
+type mockConstructorTestingTNewAsyncProducer interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewAsyncProducer creates a new instance of AsyncProducer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewAsyncProducer(t NewAsyncProducerT) *AsyncProducer {
+func NewAsyncProducer(t mockConstructorTestingTNewAsyncProducer) *AsyncProducer {
 	mock := &AsyncProducer{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Blank.go b/mocks/pkg/fixtures/Blank.go
index 0a449bb5..ed681cc8 100644
--- a/mocks/pkg/fixtures/Blank.go
+++ b/mocks/pkg/fixtures/Blank.go
@@ -23,13 +23,13 @@ func (_m *Blank) Create(x interface{}) error {
 	return r0
 }
 
-type NewBlankT interface {
+type mockConstructorTestingTNewBlank interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewBlank creates a new instance of Blank. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewBlank(t NewBlankT) *Blank {
+func NewBlank(t mockConstructorTestingTNewBlank) *Blank {
 	mock := &Blank{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/ConsulLock.go b/mocks/pkg/fixtures/ConsulLock.go
index b8fdb695..d5b8d27f 100644
--- a/mocks/pkg/fixtures/ConsulLock.go
+++ b/mocks/pkg/fixtures/ConsulLock.go
@@ -46,13 +46,13 @@ func (_m *ConsulLock) Unlock() error {
 	return r0
 }
 
-type NewConsulLockT interface {
+type mockConstructorTestingTNewConsulLock interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewConsulLock creates a new instance of ConsulLock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewConsulLock(t NewConsulLockT) *ConsulLock {
+func NewConsulLock(t mockConstructorTestingTNewConsulLock) *ConsulLock {
 	mock := &ConsulLock{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/EmbeddedGet.go b/mocks/pkg/fixtures/EmbeddedGet.go
index c91df07e..dfef71f8 100644
--- a/mocks/pkg/fixtures/EmbeddedGet.go
+++ b/mocks/pkg/fixtures/EmbeddedGet.go
@@ -26,13 +26,13 @@ func (_m *EmbeddedGet[T]) Get() T {
 	return r0
 }
 
-type NewEmbeddedGetT interface {
+type mockConstructorTestingTNewEmbeddedGet interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewEmbeddedGet creates a new instance of EmbeddedGet. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewEmbeddedGet[T constraints.Signed](t NewEmbeddedGetT) *EmbeddedGet[T] {
+func NewEmbeddedGet[T constraints.Signed](t mockConstructorTestingTNewEmbeddedGet) *EmbeddedGet[T] {
 	mock := &EmbeddedGet[T]{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Example.go b/mocks/pkg/fixtures/Example.go
index 20b55518..db089172 100644
--- a/mocks/pkg/fixtures/Example.go
+++ b/mocks/pkg/fixtures/Example.go
@@ -45,13 +45,13 @@ func (_m *Example) B(_a0 string) fixtureshttp.MyStruct {
 	return r0
 }
 
-type NewExampleT interface {
+type mockConstructorTestingTNewExample interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewExample creates a new instance of Example. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewExample(t NewExampleT) *Example {
+func NewExample(t mockConstructorTestingTNewExample) *Example {
 	mock := &Example{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Expecter.go b/mocks/pkg/fixtures/Expecter.go
index e61efde0..8f91afff 100644
--- a/mocks/pkg/fixtures/Expecter.go
+++ b/mocks/pkg/fixtures/Expecter.go
@@ -227,13 +227,13 @@ func (_c *Expecter_VariadicMany_Call) Return(_a0 error) *Expecter_VariadicMany_C
 	return _c
 }
 
-type NewExpecterT interface {
+type mockConstructorTestingTNewExpecter interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewExpecter creates a new instance of Expecter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewExpecter(t NewExpecterT) *Expecter {
+func NewExpecter(t mockConstructorTestingTNewExpecter) *Expecter {
 	mock := &Expecter{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Fooer.go b/mocks/pkg/fixtures/Fooer.go
index 24c2b3ca..1eb1eeff 100644
--- a/mocks/pkg/fixtures/Fooer.go
+++ b/mocks/pkg/fixtures/Fooer.go
@@ -44,13 +44,13 @@ func (_m *Fooer) Foo(f func(string) string) error {
 	return r0
 }
 
-type NewFooerT interface {
+type mockConstructorTestingTNewFooer interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewFooer creates a new instance of Fooer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFooer(t NewFooerT) *Fooer {
+func NewFooer(t mockConstructorTestingTNewFooer) *Fooer {
 	mock := &Fooer{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/FuncArgsCollision.go b/mocks/pkg/fixtures/FuncArgsCollision.go
index d523930c..6ecbf5c2 100644
--- a/mocks/pkg/fixtures/FuncArgsCollision.go
+++ b/mocks/pkg/fixtures/FuncArgsCollision.go
@@ -23,13 +23,13 @@ func (_m *FuncArgsCollision) Foo(ret interface{}) error {
 	return r0
 }
 
-type NewFuncArgsCollisionT interface {
+type mockConstructorTestingTNewFuncArgsCollision interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewFuncArgsCollision creates a new instance of FuncArgsCollision. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFuncArgsCollision(t NewFuncArgsCollisionT) *FuncArgsCollision {
+func NewFuncArgsCollision(t mockConstructorTestingTNewFuncArgsCollision) *FuncArgsCollision {
 	mock := &FuncArgsCollision{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/GetGeneric.go b/mocks/pkg/fixtures/GetGeneric.go
index 67d1f578..9b8079f4 100644
--- a/mocks/pkg/fixtures/GetGeneric.go
+++ b/mocks/pkg/fixtures/GetGeneric.go
@@ -26,13 +26,13 @@ func (_m *GetGeneric[T]) Get() T {
 	return r0
 }
 
-type NewGetGenericT interface {
+type mockConstructorTestingTNewGetGeneric interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewGetGeneric creates a new instance of GetGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewGetGeneric[T constraints.Integer](t NewGetGenericT) *GetGeneric[T] {
+func NewGetGeneric[T constraints.Integer](t mockConstructorTestingTNewGetGeneric) *GetGeneric[T] {
 	mock := &GetGeneric[T]{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/GetInt.go b/mocks/pkg/fixtures/GetInt.go
index 8dfe94b5..545a5997 100644
--- a/mocks/pkg/fixtures/GetInt.go
+++ b/mocks/pkg/fixtures/GetInt.go
@@ -23,13 +23,13 @@ func (_m *GetInt) Get() int {
 	return r0
 }
 
-type NewGetIntT interface {
+type mockConstructorTestingTNewGetInt interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewGetInt creates a new instance of GetInt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewGetInt(t NewGetIntT) *GetInt {
+func NewGetInt(t mockConstructorTestingTNewGetInt) *GetInt {
 	mock := &GetInt{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/HasConflictingNestedImports.go b/mocks/pkg/fixtures/HasConflictingNestedImports.go
index da63f4ad..985d6ff7 100644
--- a/mocks/pkg/fixtures/HasConflictingNestedImports.go
+++ b/mocks/pkg/fixtures/HasConflictingNestedImports.go
@@ -50,13 +50,13 @@ func (_m *HasConflictingNestedImports) Z() fixtureshttp.MyStruct {
 	return r0
 }
 
-type NewHasConflictingNestedImportsT interface {
+type mockConstructorTestingTNewHasConflictingNestedImports interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewHasConflictingNestedImports creates a new instance of HasConflictingNestedImports. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewHasConflictingNestedImports(t NewHasConflictingNestedImportsT) *HasConflictingNestedImports {
+func NewHasConflictingNestedImports(t mockConstructorTestingTNewHasConflictingNestedImports) *HasConflictingNestedImports {
 	mock := &HasConflictingNestedImports{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/ImportsSameAsPackage.go b/mocks/pkg/fixtures/ImportsSameAsPackage.go
index 94494023..ff177399 100644
--- a/mocks/pkg/fixtures/ImportsSameAsPackage.go
+++ b/mocks/pkg/fixtures/ImportsSameAsPackage.go
@@ -49,13 +49,13 @@ func (_m *ImportsSameAsPackage) C(_a0 fixtures.C) {
 	_m.Called(_a0)
 }
 
-type NewImportsSameAsPackageT interface {
+type mockConstructorTestingTNewImportsSameAsPackage interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewImportsSameAsPackage creates a new instance of ImportsSameAsPackage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewImportsSameAsPackage(t NewImportsSameAsPackageT) *ImportsSameAsPackage {
+func NewImportsSameAsPackage(t mockConstructorTestingTNewImportsSameAsPackage) *ImportsSameAsPackage {
 	mock := &ImportsSameAsPackage{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/KeyManager.go b/mocks/pkg/fixtures/KeyManager.go
index ac6ab162..da5b4bbe 100644
--- a/mocks/pkg/fixtures/KeyManager.go
+++ b/mocks/pkg/fixtures/KeyManager.go
@@ -37,13 +37,13 @@ func (_m *KeyManager) GetKey(_a0 string, _a1 uint16) ([]byte, *test.Err) {
 	return r0, r1
 }
 
-type NewKeyManagerT interface {
+type mockConstructorTestingTNewKeyManager interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewKeyManager creates a new instance of KeyManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewKeyManager(t NewKeyManagerT) *KeyManager {
+func NewKeyManager(t mockConstructorTestingTNewKeyManager) *KeyManager {
 	mock := &KeyManager{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/MapFunc.go b/mocks/pkg/fixtures/MapFunc.go
index 6e683803..eff10a3c 100644
--- a/mocks/pkg/fixtures/MapFunc.go
+++ b/mocks/pkg/fixtures/MapFunc.go
@@ -23,13 +23,13 @@ func (_m *MapFunc) Get(m map[string]func(string) string) error {
 	return r0
 }
 
-type NewMapFuncT interface {
+type mockConstructorTestingTNewMapFunc interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMapFunc creates a new instance of MapFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMapFunc(t NewMapFuncT) *MapFunc {
+func NewMapFunc(t mockConstructorTestingTNewMapFunc) *MapFunc {
 	mock := &MapFunc{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/MapToInterface.go b/mocks/pkg/fixtures/MapToInterface.go
index b299d234..83b0cf13 100644
--- a/mocks/pkg/fixtures/MapToInterface.go
+++ b/mocks/pkg/fixtures/MapToInterface.go
@@ -20,13 +20,13 @@ func (_m *MapToInterface) Foo(arg1 ...map[string]interface{}) {
 	_m.Called(_ca...)
 }
 
-type NewMapToInterfaceT interface {
+type mockConstructorTestingTNewMapToInterface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMapToInterface creates a new instance of MapToInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMapToInterface(t NewMapToInterfaceT) *MapToInterface {
+func NewMapToInterface(t mockConstructorTestingTNewMapToInterface) *MapToInterface {
 	mock := &MapToInterface{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/MyReader.go b/mocks/pkg/fixtures/MyReader.go
index 8baaf476..f677c95d 100644
--- a/mocks/pkg/fixtures/MyReader.go
+++ b/mocks/pkg/fixtures/MyReader.go
@@ -30,13 +30,13 @@ func (_m *MyReader) Read(p []byte) (int, error) {
 	return r0, r1
 }
 
-type NewMyReaderT interface {
+type mockConstructorTestingTNewMyReader interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMyReader creates a new instance of MyReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMyReader(t NewMyReaderT) *MyReader {
+func NewMyReader(t mockConstructorTestingTNewMyReader) *MyReader {
 	mock := &MyReader{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Requester.go b/mocks/pkg/fixtures/Requester.go
index 4efba2ee..c22011f2 100644
--- a/mocks/pkg/fixtures/Requester.go
+++ b/mocks/pkg/fixtures/Requester.go
@@ -30,13 +30,13 @@ func (_m *Requester) Get(path string) (string, error) {
 	return r0, r1
 }
 
-type NewRequesterT interface {
+type mockConstructorTestingTNewRequester interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester(t NewRequesterT) *Requester {
+func NewRequester(t mockConstructorTestingTNewRequester) *Requester {
 	mock := &Requester{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Requester2.go b/mocks/pkg/fixtures/Requester2.go
index 9e3c45a8..f0c20e18 100644
--- a/mocks/pkg/fixtures/Requester2.go
+++ b/mocks/pkg/fixtures/Requester2.go
@@ -23,13 +23,13 @@ func (_m *Requester2) Get(path string) error {
 	return r0
 }
 
-type NewRequester2T interface {
+type mockConstructorTestingTNewRequester2 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester2 creates a new instance of Requester2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester2(t NewRequester2T) *Requester2 {
+func NewRequester2(t mockConstructorTestingTNewRequester2) *Requester2 {
 	mock := &Requester2{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Requester3.go b/mocks/pkg/fixtures/Requester3.go
index 4de999e2..73b0b027 100644
--- a/mocks/pkg/fixtures/Requester3.go
+++ b/mocks/pkg/fixtures/Requester3.go
@@ -23,13 +23,13 @@ func (_m *Requester3) Get() error {
 	return r0
 }
 
-type NewRequester3T interface {
+type mockConstructorTestingTNewRequester3 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester3 creates a new instance of Requester3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester3(t NewRequester3T) *Requester3 {
+func NewRequester3(t mockConstructorTestingTNewRequester3) *Requester3 {
 	mock := &Requester3{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Requester4.go b/mocks/pkg/fixtures/Requester4.go
index 13085089..d4dbbdf1 100644
--- a/mocks/pkg/fixtures/Requester4.go
+++ b/mocks/pkg/fixtures/Requester4.go
@@ -14,13 +14,13 @@ func (_m *Requester4) Get() {
 	_m.Called()
 }
 
-type NewRequester4T interface {
+type mockConstructorTestingTNewRequester4 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester4 creates a new instance of Requester4. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester4(t NewRequester4T) *Requester4 {
+func NewRequester4(t mockConstructorTestingTNewRequester4) *Requester4 {
 	mock := &Requester4{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterArgSameAsImport.go b/mocks/pkg/fixtures/RequesterArgSameAsImport.go
index 0680309c..4d783b91 100644
--- a/mocks/pkg/fixtures/RequesterArgSameAsImport.go
+++ b/mocks/pkg/fixtures/RequesterArgSameAsImport.go
@@ -29,13 +29,13 @@ func (_m *RequesterArgSameAsImport) Get(_a0 string) *json.RawMessage {
 	return r0
 }
 
-type NewRequesterArgSameAsImportT interface {
+type mockConstructorTestingTNewRequesterArgSameAsImport interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsImport creates a new instance of RequesterArgSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsImport(t NewRequesterArgSameAsImportT) *RequesterArgSameAsImport {
+func NewRequesterArgSameAsImport(t mockConstructorTestingTNewRequesterArgSameAsImport) *RequesterArgSameAsImport {
 	mock := &RequesterArgSameAsImport{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterArgSameAsNamedImport.go b/mocks/pkg/fixtures/RequesterArgSameAsNamedImport.go
index 3bc50736..c0c5b782 100644
--- a/mocks/pkg/fixtures/RequesterArgSameAsNamedImport.go
+++ b/mocks/pkg/fixtures/RequesterArgSameAsNamedImport.go
@@ -29,13 +29,13 @@ func (_m *RequesterArgSameAsNamedImport) Get(_a0 string) *json.RawMessage {
 	return r0
 }
 
-type NewRequesterArgSameAsNamedImportT interface {
+type mockConstructorTestingTNewRequesterArgSameAsNamedImport interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsNamedImport creates a new instance of RequesterArgSameAsNamedImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsNamedImport(t NewRequesterArgSameAsNamedImportT) *RequesterArgSameAsNamedImport {
+func NewRequesterArgSameAsNamedImport(t mockConstructorTestingTNewRequesterArgSameAsNamedImport) *RequesterArgSameAsNamedImport {
 	mock := &RequesterArgSameAsNamedImport{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterArgSameAsPkg.go b/mocks/pkg/fixtures/RequesterArgSameAsPkg.go
index 812e899f..8328a998 100644
--- a/mocks/pkg/fixtures/RequesterArgSameAsPkg.go
+++ b/mocks/pkg/fixtures/RequesterArgSameAsPkg.go
@@ -14,13 +14,13 @@ func (_m *RequesterArgSameAsPkg) Get(_a0 string) {
 	_m.Called(_a0)
 }
 
-type NewRequesterArgSameAsPkgT interface {
+type mockConstructorTestingTNewRequesterArgSameAsPkg interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsPkg creates a new instance of RequesterArgSameAsPkg. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsPkg(t NewRequesterArgSameAsPkgT) *RequesterArgSameAsPkg {
+func NewRequesterArgSameAsPkg(t mockConstructorTestingTNewRequesterArgSameAsPkg) *RequesterArgSameAsPkg {
 	mock := &RequesterArgSameAsPkg{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterArray.go b/mocks/pkg/fixtures/RequesterArray.go
index 33577333..b5cac438 100644
--- a/mocks/pkg/fixtures/RequesterArray.go
+++ b/mocks/pkg/fixtures/RequesterArray.go
@@ -32,13 +32,13 @@ func (_m *RequesterArray) Get(path string) ([2]string, error) {
 	return r0, r1
 }
 
-type NewRequesterArrayT interface {
+type mockConstructorTestingTNewRequesterArray interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArray creates a new instance of RequesterArray. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArray(t NewRequesterArrayT) *RequesterArray {
+func NewRequesterArray(t mockConstructorTestingTNewRequesterArray) *RequesterArray {
 	mock := &RequesterArray{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterElided.go b/mocks/pkg/fixtures/RequesterElided.go
index 1aa8c8dd..3af99cb0 100644
--- a/mocks/pkg/fixtures/RequesterElided.go
+++ b/mocks/pkg/fixtures/RequesterElided.go
@@ -23,13 +23,13 @@ func (_m *RequesterElided) Get(path string, url string) error {
 	return r0
 }
 
-type NewRequesterElidedT interface {
+type mockConstructorTestingTNewRequesterElided interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterElided creates a new instance of RequesterElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterElided(t NewRequesterElidedT) *RequesterElided {
+func NewRequesterElided(t mockConstructorTestingTNewRequesterElided) *RequesterElided {
 	mock := &RequesterElided{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterGenerics.go b/mocks/pkg/fixtures/RequesterGenerics.go
index 433e1b63..6fe44588 100644
--- a/mocks/pkg/fixtures/RequesterGenerics.go
+++ b/mocks/pkg/fixtures/RequesterGenerics.go
@@ -77,7 +77,7 @@ func (_m *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TG
 	return r0
 }
 
-type NewRequesterGenericsT interface {
+type mockConstructorTestingTNewRequesterGenerics interface {
 	mock.TestingT
 	Cleanup(func())
 }
@@ -86,7 +86,7 @@ type NewRequesterGenericsT interface {
 func NewRequesterGenerics[TAny interface{}, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
 	~int | test.GenericType[int, test.GetInt]
 	comparable
-}](t NewRequesterGenericsT) *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
+}](t mockConstructorTestingTNewRequesterGenerics) *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
 	mock := &RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterIface.go b/mocks/pkg/fixtures/RequesterIface.go
index 52390ad7..41d7d7d8 100644
--- a/mocks/pkg/fixtures/RequesterIface.go
+++ b/mocks/pkg/fixtures/RequesterIface.go
@@ -29,13 +29,13 @@ func (_m *RequesterIface) Get() io.Reader {
 	return r0
 }
 
-type NewRequesterIfaceT interface {
+type mockConstructorTestingTNewRequesterIface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterIface creates a new instance of RequesterIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterIface(t NewRequesterIfaceT) *RequesterIface {
+func NewRequesterIface(t mockConstructorTestingTNewRequesterIface) *RequesterIface {
 	mock := &RequesterIface{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterNS.go b/mocks/pkg/fixtures/RequesterNS.go
index 3171e7e8..e7a69f14 100644
--- a/mocks/pkg/fixtures/RequesterNS.go
+++ b/mocks/pkg/fixtures/RequesterNS.go
@@ -34,13 +34,13 @@ func (_m *RequesterNS) Get(path string) (http.Response, error) {
 	return r0, r1
 }
 
-type NewRequesterNST interface {
+type mockConstructorTestingTNewRequesterNS interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterNS creates a new instance of RequesterNS. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterNS(t NewRequesterNST) *RequesterNS {
+func NewRequesterNS(t mockConstructorTestingTNewRequesterNS) *RequesterNS {
 	mock := &RequesterNS{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterPtr.go b/mocks/pkg/fixtures/RequesterPtr.go
index afbfba53..2d19b39b 100644
--- a/mocks/pkg/fixtures/RequesterPtr.go
+++ b/mocks/pkg/fixtures/RequesterPtr.go
@@ -32,13 +32,13 @@ func (_m *RequesterPtr) Get(path string) (*string, error) {
 	return r0, r1
 }
 
-type NewRequesterPtrT interface {
+type mockConstructorTestingTNewRequesterPtr interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterPtr creates a new instance of RequesterPtr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterPtr(t NewRequesterPtrT) *RequesterPtr {
+func NewRequesterPtr(t mockConstructorTestingTNewRequesterPtr) *RequesterPtr {
 	mock := &RequesterPtr{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterReturnElided.go b/mocks/pkg/fixtures/RequesterReturnElided.go
index 16553831..0936b208 100644
--- a/mocks/pkg/fixtures/RequesterReturnElided.go
+++ b/mocks/pkg/fixtures/RequesterReturnElided.go
@@ -44,13 +44,13 @@ func (_m *RequesterReturnElided) Get(path string) (int, int, int, error) {
 	return r0, r1, r2, r3
 }
 
-type NewRequesterReturnElidedT interface {
+type mockConstructorTestingTNewRequesterReturnElided interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterReturnElided creates a new instance of RequesterReturnElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterReturnElided(t NewRequesterReturnElidedT) *RequesterReturnElided {
+func NewRequesterReturnElided(t mockConstructorTestingTNewRequesterReturnElided) *RequesterReturnElided {
 	mock := &RequesterReturnElided{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterSlice.go b/mocks/pkg/fixtures/RequesterSlice.go
index ff5b1cf8..bf4230f5 100644
--- a/mocks/pkg/fixtures/RequesterSlice.go
+++ b/mocks/pkg/fixtures/RequesterSlice.go
@@ -32,13 +32,13 @@ func (_m *RequesterSlice) Get(path string) ([]string, error) {
 	return r0, r1
 }
 
-type NewRequesterSliceT interface {
+type mockConstructorTestingTNewRequesterSlice interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterSlice creates a new instance of RequesterSlice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterSlice(t NewRequesterSliceT) *RequesterSlice {
+func NewRequesterSlice(t mockConstructorTestingTNewRequesterSlice) *RequesterSlice {
 	mock := &RequesterSlice{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterVariadic.go b/mocks/pkg/fixtures/RequesterVariadic.go
index 1a775fb2..a5359e70 100644
--- a/mocks/pkg/fixtures/RequesterVariadic.go
+++ b/mocks/pkg/fixtures/RequesterVariadic.go
@@ -87,13 +87,13 @@ func (_m *RequesterVariadic) Sprintf(format string, a ...interface{}) string {
 	return r0
 }
 
-type NewRequesterVariadicT interface {
+type mockConstructorTestingTNewRequesterVariadic interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterVariadic creates a new instance of RequesterVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterVariadic(t NewRequesterVariadicT) *RequesterVariadic {
+func NewRequesterVariadic(t mockConstructorTestingTNewRequesterVariadic) *RequesterVariadic {
 	mock := &RequesterVariadic{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/RequesterVariadicOneArgument.go b/mocks/pkg/fixtures/RequesterVariadicOneArgument.go
index ace8bc42..f9cf19a7 100644
--- a/mocks/pkg/fixtures/RequesterVariadicOneArgument.go
+++ b/mocks/pkg/fixtures/RequesterVariadicOneArgument.go
@@ -69,13 +69,13 @@ func (_m *RequesterVariadicOneArgument) Sprintf(format string, a ...interface{})
 	return r0
 }
 
-type NewRequesterVariadicOneArgumentT interface {
+type mockConstructorTestingTNewRequesterVariadicOneArgument interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterVariadicOneArgument creates a new instance of RequesterVariadicOneArgument. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterVariadicOneArgument(t NewRequesterVariadicOneArgumentT) *RequesterVariadicOneArgument {
+func NewRequesterVariadicOneArgument(t mockConstructorTestingTNewRequesterVariadicOneArgument) *RequesterVariadicOneArgument {
 	mock := &RequesterVariadicOneArgument{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/SendFunc.go b/mocks/pkg/fixtures/SendFunc.go
index 8d460534..ee4d3e0d 100644
--- a/mocks/pkg/fixtures/SendFunc.go
+++ b/mocks/pkg/fixtures/SendFunc.go
@@ -34,13 +34,13 @@ func (_m *SendFunc) Execute(ctx context.Context, data string) (int, error) {
 	return r0, r1
 }
 
-type NewSendFuncT interface {
+type mockConstructorTestingTNewSendFunc interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewSendFunc creates a new instance of SendFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSendFunc(t NewSendFuncT) *SendFunc {
+func NewSendFunc(t mockConstructorTestingTNewSendFunc) *SendFunc {
 	mock := &SendFunc{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/Sibling.go b/mocks/pkg/fixtures/Sibling.go
index 11b33e42..e3f1f296 100644
--- a/mocks/pkg/fixtures/Sibling.go
+++ b/mocks/pkg/fixtures/Sibling.go
@@ -14,13 +14,13 @@ func (_m *Sibling) DoSomething() {
 	_m.Called()
 }
 
-type NewSiblingT interface {
+type mockConstructorTestingTNewSibling interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewSibling creates a new instance of Sibling. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSibling(t NewSiblingT) *Sibling {
+func NewSibling(t mockConstructorTestingTNewSibling) *Sibling {
 	mock := &Sibling{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/UnsafeInterface.go b/mocks/pkg/fixtures/UnsafeInterface.go
index b12f9670..ef0c9739 100644
--- a/mocks/pkg/fixtures/UnsafeInterface.go
+++ b/mocks/pkg/fixtures/UnsafeInterface.go
@@ -18,13 +18,13 @@ func (_m *UnsafeInterface) Do(ptr *unsafe.Pointer) {
 	_m.Called(ptr)
 }
 
-type NewUnsafeInterfaceT interface {
+type mockConstructorTestingTNewUnsafeInterface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewUnsafeInterface creates a new instance of UnsafeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewUnsafeInterface(t NewUnsafeInterfaceT) *UnsafeInterface {
+func NewUnsafeInterface(t mockConstructorTestingTNewUnsafeInterface) *UnsafeInterface {
 	mock := &UnsafeInterface{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/UsesOtherPkgIface.go b/mocks/pkg/fixtures/UsesOtherPkgIface.go
index b582febc..120e7015 100644
--- a/mocks/pkg/fixtures/UsesOtherPkgIface.go
+++ b/mocks/pkg/fixtures/UsesOtherPkgIface.go
@@ -17,13 +17,13 @@ func (_m *UsesOtherPkgIface) DoSomethingElse(obj test.Sibling) {
 	_m.Called(obj)
 }
 
-type NewUsesOtherPkgIfaceT interface {
+type mockConstructorTestingTNewUsesOtherPkgIface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewUsesOtherPkgIface creates a new instance of UsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewUsesOtherPkgIface(t NewUsesOtherPkgIfaceT) *UsesOtherPkgIface {
+func NewUsesOtherPkgIface(t mockConstructorTestingTNewUsesOtherPkgIface) *UsesOtherPkgIface {
 	mock := &UsesOtherPkgIface{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/buildtag/comment/IfaceWithBuildTagInComment.go b/mocks/pkg/fixtures/buildtag/comment/IfaceWithBuildTagInComment.go
index 9bdee091..8dc5d76a 100644
--- a/mocks/pkg/fixtures/buildtag/comment/IfaceWithBuildTagInComment.go
+++ b/mocks/pkg/fixtures/buildtag/comment/IfaceWithBuildTagInComment.go
@@ -26,13 +26,13 @@ func (_m *IfaceWithBuildTagInComment) Sprintf(format string, a ...interface{}) s
 	return r0
 }
 
-type NewIfaceWithBuildTagInCommentT interface {
+type mockConstructorTestingTNewIfaceWithBuildTagInComment interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewIfaceWithBuildTagInComment creates a new instance of IfaceWithBuildTagInComment. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewIfaceWithBuildTagInComment(t NewIfaceWithBuildTagInCommentT) *IfaceWithBuildTagInComment {
+func NewIfaceWithBuildTagInComment(t mockConstructorTestingTNewIfaceWithBuildTagInComment) *IfaceWithBuildTagInComment {
 	mock := &IfaceWithBuildTagInComment{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/buildtag/filename/IfaceWithBuildTagInFilename.go b/mocks/pkg/fixtures/buildtag/filename/IfaceWithBuildTagInFilename.go
index 2c2b3cde..8060c7c3 100644
--- a/mocks/pkg/fixtures/buildtag/filename/IfaceWithBuildTagInFilename.go
+++ b/mocks/pkg/fixtures/buildtag/filename/IfaceWithBuildTagInFilename.go
@@ -26,13 +26,13 @@ func (_m *IfaceWithBuildTagInFilename) Sprintf(format string, a ...interface{})
 	return r0
 }
 
-type NewIfaceWithBuildTagInFilenameT interface {
+type mockConstructorTestingTNewIfaceWithBuildTagInFilename interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewIfaceWithBuildTagInFilename creates a new instance of IfaceWithBuildTagInFilename. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewIfaceWithBuildTagInFilename(t NewIfaceWithBuildTagInFilenameT) *IfaceWithBuildTagInFilename {
+func NewIfaceWithBuildTagInFilename(t mockConstructorTestingTNewIfaceWithBuildTagInFilename) *IfaceWithBuildTagInFilename {
 	mock := &IfaceWithBuildTagInFilename{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/constraints/Integer.go b/mocks/pkg/fixtures/constraints/Integer.go
index 61b21e81..a0d9e465 100644
--- a/mocks/pkg/fixtures/constraints/Integer.go
+++ b/mocks/pkg/fixtures/constraints/Integer.go
@@ -9,13 +9,13 @@ type Integer struct {
 	mock.Mock
 }
 
-type NewIntegerT interface {
+type mockConstructorTestingTNewInteger interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewInteger creates a new instance of Integer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewInteger(t NewIntegerT) *Integer {
+func NewInteger(t mockConstructorTestingTNewInteger) *Integer {
 	mock := &Integer{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/constraints/Signed.go b/mocks/pkg/fixtures/constraints/Signed.go
index 30b94696..a1dddd0c 100644
--- a/mocks/pkg/fixtures/constraints/Signed.go
+++ b/mocks/pkg/fixtures/constraints/Signed.go
@@ -9,13 +9,13 @@ type Signed struct {
 	mock.Mock
 }
 
-type NewSignedT interface {
+type mockConstructorTestingTNewSigned interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewSigned creates a new instance of Signed. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSigned(t NewSignedT) *Signed {
+func NewSigned(t mockConstructorTestingTNewSigned) *Signed {
 	mock := &Signed{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/example_project/Root.go b/mocks/pkg/fixtures/example_project/Root.go
index ccd3d51f..0f5a11ba 100644
--- a/mocks/pkg/fixtures/example_project/Root.go
+++ b/mocks/pkg/fixtures/example_project/Root.go
@@ -40,13 +40,13 @@ func (_m *Root) TakesBaz(_a0 *foo.Baz) {
 	_m.Called(_a0)
 }
 
-type NewRootT interface {
+type mockConstructorTestingTNewRoot interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRoot creates a new instance of Root. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRoot(t NewRootT) *Root {
+func NewRoot(t mockConstructorTestingTNewRoot) *Root {
 	mock := &Root{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/example_project/bar/foo/Client.go b/mocks/pkg/fixtures/example_project/bar/foo/Client.go
index a690dcae..a8b6f07d 100644
--- a/mocks/pkg/fixtures/example_project/bar/foo/Client.go
+++ b/mocks/pkg/fixtures/example_project/bar/foo/Client.go
@@ -32,13 +32,13 @@ func (_m *Client) Search(query string) ([]string, error) {
 	return r0, r1
 }
 
-type NewClientT interface {
+type mockConstructorTestingTNewClient interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewClient(t NewClientT) *Client {
+func NewClient(t mockConstructorTestingTNewClient) *Client {
 	mock := &Client{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/example_project/context/CollideWithStdLib.go b/mocks/pkg/fixtures/example_project/context/CollideWithStdLib.go
index e1c91899..8e25f2e1 100644
--- a/mocks/pkg/fixtures/example_project/context/CollideWithStdLib.go
+++ b/mocks/pkg/fixtures/example_project/context/CollideWithStdLib.go
@@ -18,13 +18,13 @@ func (_m *CollideWithStdLib) NewClient(ctx context.Context) {
 	_m.Called(ctx)
 }
 
-type NewCollideWithStdLibT interface {
+type mockConstructorTestingTNewCollideWithStdLib interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewCollideWithStdLib creates a new instance of CollideWithStdLib. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewCollideWithStdLib(t NewCollideWithStdLibT) *CollideWithStdLib {
+func NewCollideWithStdLib(t mockConstructorTestingTNewCollideWithStdLib) *CollideWithStdLib {
 	mock := &CollideWithStdLib{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/example_project/foo/Foo.go b/mocks/pkg/fixtures/example_project/foo/Foo.go
index 16fe8c65..1470e204 100644
--- a/mocks/pkg/fixtures/example_project/foo/Foo.go
+++ b/mocks/pkg/fixtures/example_project/foo/Foo.go
@@ -49,13 +49,13 @@ func (_m *Foo) GetBaz() (*foo.Baz, error) {
 	return r0, r1
 }
 
-type NewFooT interface {
+type mockConstructorTestingTNewFoo interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewFoo creates a new instance of Foo. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFoo(t NewFooT) *Foo {
+func NewFoo(t mockConstructorTestingTNewFoo) *Foo {
 	mock := &Foo{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/example_project/foo/PackageNameSameAsImport.go b/mocks/pkg/fixtures/example_project/foo/PackageNameSameAsImport.go
index a332acc5..54278823 100644
--- a/mocks/pkg/fixtures/example_project/foo/PackageNameSameAsImport.go
+++ b/mocks/pkg/fixtures/example_project/foo/PackageNameSameAsImport.go
@@ -28,13 +28,13 @@ func (_m *PackageNameSameAsImport) NewClient() foo.Client {
 	return r0
 }
 
-type NewPackageNameSameAsImportT interface {
+type mockConstructorTestingTNewPackageNameSameAsImport interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewPackageNameSameAsImport creates a new instance of PackageNameSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewPackageNameSameAsImport(t NewPackageNameSameAsImportT) *PackageNameSameAsImport {
+func NewPackageNameSameAsImport(t mockConstructorTestingTNewPackageNameSameAsImport) *PackageNameSameAsImport {
 	mock := &PackageNameSameAsImport{}
 	mock.Mock.Test(t)
 
diff --git a/mocks/pkg/fixtures/mocks/NewExpecterTestT.go b/mocks/pkg/fixtures/mocks/NewExpecterTestT.go
deleted file mode 100644
index f4d209e3..00000000
--- a/mocks/pkg/fixtures/mocks/NewExpecterTestT.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import mock "github.com/stretchr/testify/mock"
-
-// NewExpecterTestT is an autogenerated mock type for the NewExpecterTestT type
-type NewExpecterTestT struct {
-	mock.Mock
-}
-
-// Cleanup provides a mock function with given fields: _a0
-func (_m *NewExpecterTestT) Cleanup(_a0 func()) {
-	_m.Called(_a0)
-}
-
-// Errorf provides a mock function with given fields: format, args
-func (_m *NewExpecterTestT) Errorf(format string, args ...interface{}) {
-	var _ca []interface{}
-	_ca = append(_ca, format)
-	_ca = append(_ca, args...)
-	_m.Called(_ca...)
-}
-
-// FailNow provides a mock function with given fields:
-func (_m *NewExpecterTestT) FailNow() {
-	_m.Called()
-}
-
-// Logf provides a mock function with given fields: format, args
-func (_m *NewExpecterTestT) Logf(format string, args ...interface{}) {
-	var _ca []interface{}
-	_ca = append(_ca, format)
-	_ca = append(_ca, args...)
-	_m.Called(_ca...)
-}
-
-type NewNewExpecterTestTT interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewNewExpecterTestT creates a new instance of NewExpecterTestT. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewNewExpecterTestT(t NewNewExpecterTestTT) *NewExpecterTestT {
-	mock := &NewExpecterTestT{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}
diff --git a/mocks/pkg/fixtures/requester_unexported.go b/mocks/pkg/fixtures/requester_unexported.go
index 19508b7d..a5487329 100644
--- a/mocks/pkg/fixtures/requester_unexported.go
+++ b/mocks/pkg/fixtures/requester_unexported.go
@@ -14,13 +14,13 @@ func (_m *requester_unexported) Get() {
 	_m.Called()
 }
 
-type newRequester_unexportedT interface {
+type mockConstructorTestingTnewRequester_unexported interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // newRequester_unexported creates a new instance of requester_unexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func newRequester_unexported(t newRequester_unexportedT) *requester_unexported {
+func newRequester_unexported(t mockConstructorTestingTnewRequester_unexported) *requester_unexported {
 	mock := &requester_unexported{}
 	mock.Mock.Test(t)
 
diff --git a/pkg/generator.go b/pkg/generator.go
index 539dc17f..cafbc1fc 100644
--- a/pkg/generator.go
+++ b/pkg/generator.go
@@ -24,6 +24,8 @@ import (
 	"golang.org/x/tools/imports"
 )
 
+const mockConstructorParamTypeNamePrefix = "mockConstructorTestingT"
+
 var invalidIdentifierChar = regexp.MustCompile("[^[:digit:][:alpha:]_]")
 
 // Generator is responsible for generating the string containing
@@ -834,7 +836,7 @@ func {{ .ConstructorName }}{{ .TypeConstraint }}(t {{ .ConstructorTestingInterfa
 		TypeConstraint                  string
 	}{
 		ConstructorName:                 constructorName,
-		ConstructorTestingInterfaceName: constructorName + "T",
+		ConstructorTestingInterfaceName: mockConstructorParamTypeNamePrefix + constructorName,
 		InstantiatedTypeString:          g.getInstantiatedTypeString(),
 		MockName:                        mockName,
 		TypeConstraint:                  g.getTypeConstraintString(ctx),
diff --git a/pkg/generator_test.go b/pkg/generator_test.go
index c5ca040e..98313d1c 100644
--- a/pkg/generator_test.go
+++ b/pkg/generator_test.go
@@ -152,13 +152,13 @@ func (_m *Requester) Get(path string) (string, error) {
 	return r0, r1
 }
 
-type NewRequesterT interface {
+type mockConstructorTestingTNewRequester interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester(t NewRequesterT) *Requester {
+func NewRequester(t mockConstructorTestingTNewRequester) *Requester {
 	mock := &Requester{}
 	mock.Mock.Test(t)
 
@@ -228,13 +228,13 @@ func (_c *Requester_Get_Call) Return(_a0 string, _a1 error) *Requester_Get_Call
 	return _c
 }
 
-type NewRequesterT interface {
+type mockConstructorTestingTNewRequester interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester(t NewRequesterT) *Requester {
+func NewRequester(t mockConstructorTestingTNewRequester) *Requester {
 	mock := &Requester{}
 	mock.Mock.Test(t)
 
@@ -475,13 +475,13 @@ func (_c *Expecter_VariadicMany_Call) Return(_a0 error) *Expecter_VariadicMany_C
 	return _c
 }
 
-type NewExpecterT interface {
+type mockConstructorTestingTNewExpecter interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewExpecter creates a new instance of Expecter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewExpecter(t NewExpecterT) *Expecter {
+func NewExpecter(t mockConstructorTestingTNewExpecter) *Expecter {
 	mock := &Expecter{}
 	mock.Mock.Test(t)
 
@@ -537,13 +537,13 @@ func (_m *SendFunc) Execute(ctx context.Context, data string) (int, error) {
 	return r0, r1
 }
 
-type NewSendFuncT interface {
+type mockConstructorTestingTNewSendFunc interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewSendFunc creates a new instance of SendFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSendFunc(t NewSendFuncT) *SendFunc {
+func NewSendFunc(t mockConstructorTestingTNewSendFunc) *SendFunc {
 	mock := &SendFunc{}
 	mock.Mock.Test(t)
 
@@ -575,13 +575,13 @@ func (_m *Requester2) Get(path string) error {
 	return r0
 }
 
-type NewRequester2T interface {
+type mockConstructorTestingTNewRequester2 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester2 creates a new instance of Requester2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester2(t NewRequester2T) *Requester2 {
+func NewRequester2(t mockConstructorTestingTNewRequester2) *Requester2 {
 	mock := &Requester2{}
 	mock.Mock.Test(t)
 
@@ -613,13 +613,13 @@ func (_m *Requester3) Get() error {
 	return r0
 }
 
-type NewRequester3T interface {
+type mockConstructorTestingTNewRequester3 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester3 creates a new instance of Requester3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester3(t NewRequester3T) *Requester3 {
+func NewRequester3(t mockConstructorTestingTNewRequester3) *Requester3 {
 	mock := &Requester3{}
 	mock.Mock.Test(t)
 
@@ -642,13 +642,13 @@ func (_m *Requester4) Get() {
 	_m.Called()
 }
 
-type NewRequester4T interface {
+type mockConstructorTestingTNewRequester4 interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester4 creates a new instance of Requester4. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester4(t NewRequester4T) *Requester4 {
+func NewRequester4(t mockConstructorTestingTNewRequester4) *Requester4 {
 	mock := &Requester4{}
 	mock.Mock.Test(t)
 
@@ -671,13 +671,13 @@ func (_m *mockRequester_unexported) Get() {
 	_m.Called()
 }
 
-type newMockRequester_unexportedT interface {
+type mockConstructorTestingTnewMockRequester_unexported interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // newMockRequester_unexported creates a new instance of mockRequester_unexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func newMockRequester_unexported(t newMockRequester_unexportedT) *mockRequester_unexported {
+func newMockRequester_unexported(t mockConstructorTestingTnewMockRequester_unexported) *mockRequester_unexported {
 	mock := &mockRequester_unexported{}
 	mock.Mock.Test(t)
 
@@ -700,13 +700,13 @@ func (_m *Mockrequester_unexported) Get() {
 	_m.Called()
 }
 
-type NewMockrequester_unexportedT interface {
+type mockConstructorTestingTNewMockrequester_unexported interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMockrequester_unexported creates a new instance of Mockrequester_unexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMockrequester_unexported(t NewMockrequester_unexportedT) *Mockrequester_unexported {
+func NewMockrequester_unexported(t mockConstructorTestingTNewMockrequester_unexported) *Mockrequester_unexported {
 	mock := &Mockrequester_unexported{}
 	mock.Mock.Test(t)
 
@@ -748,13 +748,13 @@ func (_m *Requester_unexported) Get() {
 	_m.Called()
 }
 
-type NewRequester_unexportedT interface {
+type mockConstructorTestingTNewRequester_unexported interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester_unexported creates a new instance of Requester_unexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester_unexported(t NewRequester_unexportedT) *Requester_unexported {
+func NewRequester_unexported(t mockConstructorTestingTNewRequester_unexported) *Requester_unexported {
 	mock := &Requester_unexported{}
 	mock.Mock.Test(t)
 
@@ -899,13 +899,13 @@ func (_m *RequesterIface) Get() io.Reader {
 	return r0
 }
 
-type NewRequesterIfaceT interface {
+type mockConstructorTestingTNewRequesterIface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterIface creates a new instance of RequesterIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterIface(t NewRequesterIfaceT) *RequesterIface {
+func NewRequesterIface(t mockConstructorTestingTNewRequesterIface) *RequesterIface {
 	mock := &RequesterIface{}
 	mock.Mock.Test(t)
 
@@ -946,13 +946,13 @@ func (_m *RequesterPtr) Get(path string) (*string, error) {
 	return r0, r1
 }
 
-type NewRequesterPtrT interface {
+type mockConstructorTestingTNewRequesterPtr interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterPtr creates a new instance of RequesterPtr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterPtr(t NewRequesterPtrT) *RequesterPtr {
+func NewRequesterPtr(t mockConstructorTestingTNewRequesterPtr) *RequesterPtr {
 	mock := &RequesterPtr{}
 	mock.Mock.Test(t)
 
@@ -993,13 +993,13 @@ func (_m *RequesterSlice) Get(path string) ([]string, error) {
 	return r0, r1
 }
 
-type NewRequesterSliceT interface {
+type mockConstructorTestingTNewRequesterSlice interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterSlice creates a new instance of RequesterSlice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterSlice(t NewRequesterSliceT) *RequesterSlice {
+func NewRequesterSlice(t mockConstructorTestingTNewRequesterSlice) *RequesterSlice {
 	mock := &RequesterSlice{}
 	mock.Mock.Test(t)
 
@@ -1040,13 +1040,13 @@ func (_m *RequesterArray) Get(path string) ([2]string, error) {
 	return r0, r1
 }
 
-type NewRequesterArrayT interface {
+type mockConstructorTestingTNewRequesterArray interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArray creates a new instance of RequesterArray. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArray(t NewRequesterArrayT) *RequesterArray {
+func NewRequesterArray(t mockConstructorTestingTNewRequesterArray) *RequesterArray {
 	mock := &RequesterArray{}
 	mock.Mock.Test(t)
 
@@ -1085,13 +1085,13 @@ func (_m *RequesterNS) Get(path string) (http.Response, error) {
 	return r0, r1
 }
 
-type NewRequesterNST interface {
+type mockConstructorTestingTNewRequesterNS interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterNS creates a new instance of RequesterNS. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterNS(t NewRequesterNST) *RequesterNS {
+func NewRequesterNS(t mockConstructorTestingTNewRequesterNS) *RequesterNS {
 	mock := &RequesterNS{}
 	mock.Mock.Test(t)
 
@@ -1125,13 +1125,13 @@ func (_m *RequesterArgSameAsImport) Get(_a0 string) *json.RawMessage {
 	return r0
 }
 
-type NewRequesterArgSameAsImportT interface {
+type mockConstructorTestingTNewRequesterArgSameAsImport interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsImport creates a new instance of RequesterArgSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsImport(t NewRequesterArgSameAsImportT) *RequesterArgSameAsImport {
+func NewRequesterArgSameAsImport(t mockConstructorTestingTNewRequesterArgSameAsImport) *RequesterArgSameAsImport {
 	mock := &RequesterArgSameAsImport{}
 	mock.Mock.Test(t)
 
@@ -1165,13 +1165,13 @@ func (_m *RequesterArgSameAsNamedImport) Get(_a0 string) *json.RawMessage {
 	return r0
 }
 
-type NewRequesterArgSameAsNamedImportT interface {
+type mockConstructorTestingTNewRequesterArgSameAsNamedImport interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsNamedImport creates a new instance of RequesterArgSameAsNamedImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsNamedImport(t NewRequesterArgSameAsNamedImportT) *RequesterArgSameAsNamedImport {
+func NewRequesterArgSameAsNamedImport(t mockConstructorTestingTNewRequesterArgSameAsNamedImport) *RequesterArgSameAsNamedImport {
 	mock := &RequesterArgSameAsNamedImport{}
 	mock.Mock.Test(t)
 
@@ -1194,13 +1194,13 @@ func (_m *RequesterArgSameAsPkg) Get(_a0 string) {
 	_m.Called(_a0)
 }
 
-type NewRequesterArgSameAsPkgT interface {
+type mockConstructorTestingTNewRequesterArgSameAsPkg interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterArgSameAsPkg creates a new instance of RequesterArgSameAsPkg. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterArgSameAsPkg(t NewRequesterArgSameAsPkgT) *RequesterArgSameAsPkg {
+func NewRequesterArgSameAsPkg(t mockConstructorTestingTNewRequesterArgSameAsPkg) *RequesterArgSameAsPkg {
 	mock := &RequesterArgSameAsPkg{}
 	mock.Mock.Test(t)
 
@@ -1243,13 +1243,13 @@ func (_m *KeyManager) GetKey(_a0 string, _a1 uint16) ([]byte, *test.Err) {
 	return r0, r1
 }
 
-type NewKeyManagerT interface {
+type mockConstructorTestingTNewKeyManager interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewKeyManager creates a new instance of KeyManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewKeyManager(t NewKeyManagerT) *KeyManager {
+func NewKeyManager(t mockConstructorTestingTNewKeyManager) *KeyManager {
 	mock := &KeyManager{}
 	mock.Mock.Test(t)
 
@@ -1281,13 +1281,13 @@ func (_m *RequesterElided) Get(path string, url string) error {
 	return r0
 }
 
-type NewRequesterElidedT interface {
+type mockConstructorTestingTNewRequesterElided interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterElided creates a new instance of RequesterElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterElided(t NewRequesterElidedT) *RequesterElided {
+func NewRequesterElided(t mockConstructorTestingTNewRequesterElided) *RequesterElided {
 	mock := &RequesterElided{}
 	mock.Mock.Test(t)
 
@@ -1340,13 +1340,13 @@ func (_m *RequesterReturnElided) Get(path string) (int, int, int, error) {
 	return r0, r1, r2, r3
 }
 
-type NewRequesterReturnElidedT interface {
+type mockConstructorTestingTNewRequesterReturnElided interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequesterReturnElided creates a new instance of RequesterReturnElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequesterReturnElided(t NewRequesterReturnElidedT) *RequesterReturnElided {
+func NewRequesterReturnElided(t mockConstructorTestingTNewRequesterReturnElided) *RequesterReturnElided {
 	mock := &RequesterReturnElided{}
 	mock.Mock.Test(t)
 
@@ -1524,13 +1524,13 @@ func (_m *Fooer) Foo(f func(string) string) error {
 	return r0
 }
 
-type NewFooerT interface {
+type mockConstructorTestingTNewFooer interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewFooer creates a new instance of Fooer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFooer(t NewFooerT) *Fooer {
+func NewFooer(t mockConstructorTestingTNewFooer) *Fooer {
 	mock := &Fooer{}
 	mock.Mock.Test(t)
 
@@ -1596,13 +1596,13 @@ func (_m *AsyncProducer) Whatever() chan bool {
 	return r0
 }
 
-type NewAsyncProducerT interface {
+type mockConstructorTestingTNewAsyncProducer interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewAsyncProducer creates a new instance of AsyncProducer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewAsyncProducer(t NewAsyncProducerT) *AsyncProducer {
+func NewAsyncProducer(t mockConstructorTestingTNewAsyncProducer) *AsyncProducer {
 	mock := &AsyncProducer{}
 	mock.Mock.Test(t)
 
@@ -1641,13 +1641,13 @@ func (_m *MyReader) Read(p []byte) (int, error) {
 	return r0, r1
 }
 
-type NewMyReaderT interface {
+type mockConstructorTestingTNewMyReader interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMyReader creates a new instance of MyReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMyReader(t NewMyReaderT) *MyReader {
+func NewMyReader(t mockConstructorTestingTNewMyReader) *MyReader {
 	mock := &MyReader{}
 	mock.Mock.Test(t)
 
@@ -1702,13 +1702,13 @@ func (_m *ConsulLock) Unlock() error {
 	return r0
 }
 
-type NewConsulLockT interface {
+type mockConstructorTestingTNewConsulLock interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewConsulLock creates a new instance of ConsulLock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewConsulLock(t NewConsulLockT) *ConsulLock {
+func NewConsulLock(t mockConstructorTestingTNewConsulLock) *ConsulLock {
 	mock := &ConsulLock{}
 	mock.Mock.Test(t)
 
@@ -1740,13 +1740,13 @@ func (_m *Blank) Create(x interface{}) error {
 	return r0
 }
 
-type NewBlankT interface {
+type mockConstructorTestingTNewBlank interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewBlank creates a new instance of Blank. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewBlank(t NewBlankT) *Blank {
+func NewBlank(t mockConstructorTestingTNewBlank) *Blank {
 	mock := &Blank{}
 	mock.Mock.Test(t)
 
@@ -1778,13 +1778,13 @@ func (_m *MapFunc) Get(m map[string]func(string) string) error {
 	return r0
 }
 
-type NewMapFuncT interface {
+type mockConstructorTestingTNewMapFunc interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMapFunc creates a new instance of MapFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMapFunc(t NewMapFuncT) *MapFunc {
+func NewMapFunc(t mockConstructorTestingTNewMapFunc) *MapFunc {
 	mock := &MapFunc{}
 	mock.Mock.Test(t)
 
@@ -1807,13 +1807,13 @@ func (_m *UsesOtherPkgIface) DoSomethingElse(obj test.Sibling) {
 	_m.Called(obj)
 }
 
-type NewUsesOtherPkgIfaceT interface {
+type mockConstructorTestingTNewUsesOtherPkgIface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewUsesOtherPkgIface creates a new instance of UsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewUsesOtherPkgIface(t NewUsesOtherPkgIfaceT) *UsesOtherPkgIface {
+func NewUsesOtherPkgIface(t mockConstructorTestingTNewUsesOtherPkgIface) *UsesOtherPkgIface {
 	mock := &UsesOtherPkgIface{}
 	mock.Mock.Test(t)
 
@@ -1836,13 +1836,13 @@ func (_m *MockUsesOtherPkgIface) DoSomethingElse(obj Sibling) {
 	_m.Called(obj)
 }
 
-type NewMockUsesOtherPkgIfaceT interface {
+type mockConstructorTestingTNewMockUsesOtherPkgIface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMockUsesOtherPkgIface creates a new instance of MockUsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMockUsesOtherPkgIface(t NewMockUsesOtherPkgIfaceT) *MockUsesOtherPkgIface {
+func NewMockUsesOtherPkgIface(t mockConstructorTestingTNewMockUsesOtherPkgIface) *MockUsesOtherPkgIface {
 	mock := &MockUsesOtherPkgIface{}
 	mock.Mock.Test(t)
 
@@ -1890,13 +1890,13 @@ func (_m *Example) B(_a0 string) fixtureshttp.MyStruct {
 	return r0
 }
 
-type NewExampleT interface {
+type mockConstructorTestingTNewExample interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewExample creates a new instance of Example. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewExample(t NewExampleT) *Example {
+func NewExample(t mockConstructorTestingTNewExample) *Example {
 	mock := &Example{}
 	mock.Mock.Test(t)
 
@@ -1935,13 +1935,13 @@ func (_m *MapToInterface) Foo(arg1 ...map[string]interface{}) {
 	_m.Called(_ca...)
 }
 
-type NewMapToInterfaceT interface {
+type mockConstructorTestingTNewMapToInterface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewMapToInterface creates a new instance of MapToInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewMapToInterface(t NewMapToInterfaceT) *MapToInterface {
+func NewMapToInterface(t mockConstructorTestingTNewMapToInterface) *MapToInterface {
 	mock := &MapToInterface{}
 	mock.Mock.Test(t)
 
@@ -1974,13 +1974,13 @@ func (_m *FuncArgsCollision) Foo(ret interface{}) error {
 	return r0
 }
 
-type NewFuncArgsCollisionT interface {
+type mockConstructorTestingTNewFuncArgsCollision interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewFuncArgsCollision creates a new instance of FuncArgsCollision. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewFuncArgsCollision(t NewFuncArgsCollisionT) *FuncArgsCollision {
+func NewFuncArgsCollision(t mockConstructorTestingTNewFuncArgsCollision) *FuncArgsCollision {
 	mock := &FuncArgsCollision{}
 	mock.Mock.Test(t)
 
@@ -2033,13 +2033,13 @@ func (_m *ImportsSameAsPackage) C(_a0 fixtures.C) {
 	_m.Called(_a0)
 }
 
-type NewImportsSameAsPackageT interface {
+type mockConstructorTestingTNewImportsSameAsPackage interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewImportsSameAsPackage creates a new instance of ImportsSameAsPackage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewImportsSameAsPackage(t NewImportsSameAsPackageT) *ImportsSameAsPackage {
+func NewImportsSameAsPackage(t mockConstructorTestingTNewImportsSameAsPackage) *ImportsSameAsPackage {
 	mock := &ImportsSameAsPackage{}
 	mock.Mock.Test(t)
 
@@ -2062,13 +2062,13 @@ func (_m *UnsafeInterface) Do(ptr *unsafe.Pointer) {
 	_m.Called(ptr)
 }
 
-type NewUnsafeInterfaceT interface {
+type mockConstructorTestingTNewUnsafeInterface interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewUnsafeInterface creates a new instance of UnsafeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewUnsafeInterface(t NewUnsafeInterfaceT) *UnsafeInterface {
+func NewUnsafeInterface(t mockConstructorTestingTNewUnsafeInterface) *UnsafeInterface {
 	mock := &UnsafeInterface{}
 	mock.Mock.Test(t)
 
@@ -2137,13 +2137,13 @@ func (_m *A) Call() (test.B, error) {
 	return r0, r1
 }
 
-type NewAT interface {
+type mockConstructorTestingTNewA interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewA creates a new instance of A. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewA(t NewAT) *A {
+func NewA(t mockConstructorTestingTNewA) *A {
 	mock := &A{}
 	mock.Mock.Test(t)
 
@@ -2175,13 +2175,13 @@ func (_m *Requester2OverrideName) Get(path string) error {
 	return r0
 }
 
-type NewRequester2OverrideNameT interface {
+type mockConstructorTestingTNewRequester2OverrideName interface {
 	mock.TestingT
 	Cleanup(func())
 }
 
 // NewRequester2OverrideName creates a new instance of Requester2OverrideName. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewRequester2OverrideName(t NewRequester2OverrideNameT) *Requester2OverrideName {
+func NewRequester2OverrideName(t mockConstructorTestingTNewRequester2OverrideName) *Requester2OverrideName {
 	mock := &Requester2OverrideName{}
 	mock.Mock.Test(t)
 
@@ -2325,7 +2325,7 @@ func (_m *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TG
 	return r0
 }
 
-type NewRequesterGenericsT interface {
+type mockConstructorTestingTNewRequesterGenerics interface {
 	mock.TestingT
 	Cleanup(func())
 }
@@ -2334,7 +2334,7 @@ type NewRequesterGenericsT interface {
 func NewRequesterGenerics[TAny interface{}, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
 	~int | test.GenericType[int, test.GetInt]
 	comparable
-}](t NewRequesterGenericsT) *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
+}](t mockConstructorTestingTNewRequesterGenerics) *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
 	mock := &RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{}
 	mock.Mock.Test(t)
 
@@ -2412,7 +2412,7 @@ func (_m *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf
 	return r0
 }
 
-type NewMockRequesterGenericsT interface {
+type mockConstructorTestingTNewMockRequesterGenerics interface {
 	mock.TestingT
 	Cleanup(func())
 }
@@ -2421,7 +2421,7 @@ type NewMockRequesterGenericsT interface {
 func NewMockRequesterGenerics[TAny interface{}, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
 	~int | GenericType[int, GetInt]
 	comparable
-}](t NewMockRequesterGenericsT) *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
+}](t mockConstructorTestingTNewMockRequesterGenerics) *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
 	mock := &MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{}
 	mock.Mock.Test(t)
 
diff --git a/pkg/walker.go b/pkg/walker.go
index 9b0dcf5c..a05aa662 100644
--- a/pkg/walker.go
+++ b/pkg/walker.go
@@ -45,6 +45,10 @@ func (w *Walker) Walk(ctx context.Context, visitor WalkerVisitor) (generated boo
 	}
 
 	for _, iface := range parser.Interfaces() {
+		if strings.HasPrefix(iface.Name, mockConstructorParamTypeNamePrefix) {
+			continue
+		}
+
 		if !w.Filter.MatchString(iface.Name) {
 			continue
 		}