diff --git a/mockgen/internal/tests/generics/generics.go b/mockgen/internal/tests/generics/generics.go
index 5ff70f8c..24b51858 100644
--- a/mockgen/internal/tests/generics/generics.go
+++ b/mockgen/internal/tests/generics/generics.go
@@ -6,7 +6,7 @@ import (
 )
 
 //go:generate mockgen --source=generics.go --destination=source/mock_generics_mock.go --package source
-//go:generate mockgen --destination=package_mode/mock_test.go --package=package_mode . Bar,Universe,MilkyWay,SolarSystem,Earth,Water
+//go:generate mockgen --destination=package_mode/mock_test.go --package=package_mode . Bar,BarAliasIntString,Universe,MilkyWay,SolarSystem,Earth,Water
 
 type Bar[T any, R any] interface {
 	One(string) string
@@ -30,9 +30,14 @@ type Bar[T any, R any] interface {
 	Nineteen() AliasType
 }
 
+// BarAliasIntString is an alias of a generic type.
+type BarAliasIntString = Bar[int, string]
+
 type Foo[T any, R any] struct{}
 
-type Baz[T any] struct{}
+type Baz[T any] struct {
+	V T
+}
 
 type Iface[T any] any
 
diff --git a/mockgen/internal/tests/generics/generics_alias.go b/mockgen/internal/tests/generics/generics_alias.go
new file mode 100644
index 00000000..2a65004c
--- /dev/null
+++ b/mockgen/internal/tests/generics/generics_alias.go
@@ -0,0 +1,18 @@
+//go:build go1.24
+
+package generics
+
+//go:generate mockgen --build_constraint go1.24 --destination=package_mode/mock_generics_alias_test.go --package=package_mode . BarAliasTString,BarAliasIntR,BarAliasIntBazR,BarAliasIntBazString
+
+// BarAliasTString is a generic alias of a generic with one complete and one
+// generic type arg.
+type BarAliasTString[T any] = Bar[T, string]
+
+// BarAliasIntR is a generic alias of a generic with a renamed type param.
+type BarAliasIntR[Q any] = Bar[int, Q]
+
+// BarAliasIntBazR is a generic alias of a generic alias with a generic type arg.
+type BarAliasIntBazR[Q any] = Bar[int, Baz[Q]]
+
+// BarAliasIntBazString is an alias of a generic alias.
+type BarAliasIntBazString = BarAliasIntBazR[string]
diff --git a/mockgen/internal/tests/generics/package_mode/generics_alias_test.go b/mockgen/internal/tests/generics/package_mode/generics_alias_test.go
new file mode 100644
index 00000000..a7e2eea6
--- /dev/null
+++ b/mockgen/internal/tests/generics/package_mode/generics_alias_test.go
@@ -0,0 +1,58 @@
+//go:build go1.24
+
+package package_mode
+
+import (
+	"testing"
+
+	"go.uber.org/mock/gomock"
+	"go.uber.org/mock/mockgen/internal/tests/generics"
+)
+
+func TestMockGenericAliasOfGeneric(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockBarAliasIntR[string](ctrl)
+	m.EXPECT().Three(10).Return("bar")
+
+	alias := generics.Bar[int, string](m)
+	if v := alias.Three(10); v != "bar" {
+		t.Errorf("Three(10) = %v, want %v", v, "bar")
+	}
+}
+
+func TestMockGenericAliasOfGenericWithRenamedTypeParam(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockBarAliasTString[int](ctrl)
+	m.EXPECT().Three(10).Return("bar")
+
+	alias := generics.Bar[int, string](m)
+	if v := alias.Three(10); v != "bar" {
+		t.Errorf("Three(10) = %v, want %v", v, "bar")
+	}
+}
+
+func TestMockGenericAliasOfGenericWithGenericTypeArg(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockBarAliasIntBazR[string](ctrl)
+	m.EXPECT().Three(10).Return(generics.Baz[string]{V: "bar"})
+
+	alias := generics.Bar[int, generics.Baz[string]](m)
+	if v := alias.Three(10); v != (generics.Baz[string]{V: "bar"}) {
+		t.Errorf("Three(10) = %v, want %v", v, "bar")
+	}
+}
+
+func TestMockAliasOfInstatiatedGenericAlias(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockBarAliasIntBazString(ctrl)
+	m.EXPECT().Three(10).Return(generics.Baz[string]{V: "bar"})
+
+	alias := generics.Bar[int, generics.Baz[string]](m)
+	if v := alias.Three(10); v != (generics.Baz[string]{V: "bar"}) {
+		t.Errorf("Three(10) = %v, want %v", v, "bar")
+	}
+}
diff --git a/mockgen/internal/tests/generics/package_mode/generics_test.go b/mockgen/internal/tests/generics/package_mode/generics_test.go
new file mode 100644
index 00000000..aaa44af3
--- /dev/null
+++ b/mockgen/internal/tests/generics/package_mode/generics_test.go
@@ -0,0 +1,50 @@
+package package_mode
+
+import (
+	"context"
+	"testing"
+
+	"go.uber.org/mock/gomock"
+	"go.uber.org/mock/mockgen/internal/tests/generics"
+)
+
+func TestMockEmbeddingIface_One(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockEmbeddingIface[int, float64](ctrl)
+	m.EXPECT().One("foo").Return("bar")
+	if v := m.One("foo"); v != "bar" {
+		t.Errorf("One() = %v, want %v", v, "bar")
+	}
+}
+
+func TestMockUniverse_Water(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockUniverse[int](ctrl)
+	m.EXPECT().Water(1024)
+	m.Water(1024)
+}
+
+func TestNewMockGroup_Join(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockGroup[generics.Generator[any]](ctrl)
+	ctx := context.TODO()
+	m.EXPECT().Join(ctx).Return(nil)
+	if v := m.Join(ctx); v != nil {
+		t.Errorf("Join() = %v, want %v", v, nil)
+	}
+}
+
+func TestMockAliasOfInstantiatedGeneric(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	m := NewMockBarAliasIntString(ctrl)
+	m.EXPECT().Three(10).Return("bar")
+
+	alias := generics.Bar[int, string](m)
+	if v := alias.Three(10); v != "bar" {
+		t.Errorf("Three(10) = %v, want %v", v, "bar")
+	}
+}
diff --git a/mockgen/internal/tests/generics/package_mode/mock_generics_alias_test.go b/mockgen/internal/tests/generics/package_mode/mock_generics_alias_test.go
new file mode 100644
index 00000000..161d5750
--- /dev/null
+++ b/mockgen/internal/tests/generics/package_mode/mock_generics_alias_test.go
@@ -0,0 +1,1196 @@
+//go:build go1.24
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: go.uber.org/mock/mockgen/internal/tests/generics (interfaces: BarAliasTString,BarAliasIntR,BarAliasIntBazR,BarAliasIntBazString)
+//
+// Generated by this command:
+//
+//	mockgen --build_constraint go1.24 --destination=package_mode/mock_generics_alias_test.go --package=package_mode . BarAliasTString,BarAliasIntR,BarAliasIntBazR,BarAliasIntBazString
+//
+
+// Package package_mode is a generated GoMock package.
+package package_mode
+
+import (
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+	generics "go.uber.org/mock/mockgen/internal/tests/generics"
+	other "go.uber.org/mock/mockgen/internal/tests/generics/other"
+)
+
+// MockBarAliasTString is a mock of BarAliasTString interface.
+type MockBarAliasTString[T any] struct {
+	ctrl     *gomock.Controller
+	recorder *MockBarAliasTStringMockRecorder[T]
+	isgomock struct{}
+}
+
+// MockBarAliasTStringMockRecorder is the mock recorder for MockBarAliasTString.
+type MockBarAliasTStringMockRecorder[T any] struct {
+	mock *MockBarAliasTString[T]
+}
+
+// NewMockBarAliasTString creates a new mock instance.
+func NewMockBarAliasTString[T any](ctrl *gomock.Controller) *MockBarAliasTString[T] {
+	mock := &MockBarAliasTString[T]{ctrl: ctrl}
+	mock.recorder = &MockBarAliasTStringMockRecorder[T]{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBarAliasTString[T]) EXPECT() *MockBarAliasTStringMockRecorder[T] {
+	return m.recorder
+}
+
+// Eight mocks base method.
+func (m *MockBarAliasTString[T]) Eight(arg0 T) other.Two[T, string] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eight", arg0)
+	ret0, _ := ret[0].(other.Two[T, string])
+	return ret0
+}
+
+// Eight indicates an expected call of Eight.
+func (mr *MockBarAliasTStringMockRecorder[T]) Eight(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBarAliasTString[T])(nil).Eight), arg0)
+}
+
+// Eighteen mocks base method.
+func (m *MockBarAliasTString[T]) Eighteen() (generics.Iface[*other.Five], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eighteen")
+	ret0, _ := ret[0].(generics.Iface[*other.Five])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eighteen indicates an expected call of Eighteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Eighteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Eighteen))
+}
+
+// Eleven mocks base method.
+func (m *MockBarAliasTString[T]) Eleven() (*other.One[T], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eleven")
+	ret0, _ := ret[0].(*other.One[T])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eleven indicates an expected call of Eleven.
+func (mr *MockBarAliasTStringMockRecorder[T]) Eleven() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBarAliasTString[T])(nil).Eleven))
+}
+
+// Fifteen mocks base method.
+func (m *MockBarAliasTString[T]) Fifteen() (generics.Iface[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fifteen")
+	ret0, _ := ret[0].(generics.Iface[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fifteen indicates an expected call of Fifteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Fifteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Fifteen))
+}
+
+// Five mocks base method.
+func (m *MockBarAliasTString[T]) Five(arg0 T) generics.Baz[T] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Five", arg0)
+	ret0, _ := ret[0].(generics.Baz[T])
+	return ret0
+}
+
+// Five indicates an expected call of Five.
+func (mr *MockBarAliasTStringMockRecorder[T]) Five(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBarAliasTString[T])(nil).Five), arg0)
+}
+
+// Four mocks base method.
+func (m *MockBarAliasTString[T]) Four(arg0 T) generics.Foo[T, string] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Four", arg0)
+	ret0, _ := ret[0].(generics.Foo[T, string])
+	return ret0
+}
+
+// Four indicates an expected call of Four.
+func (mr *MockBarAliasTStringMockRecorder[T]) Four(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBarAliasTString[T])(nil).Four), arg0)
+}
+
+// Fourteen mocks base method.
+func (m *MockBarAliasTString[T]) Fourteen() (*generics.Foo[generics.StructType, generics.StructType2], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fourteen")
+	ret0, _ := ret[0].(*generics.Foo[generics.StructType, generics.StructType2])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fourteen indicates an expected call of Fourteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Fourteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Fourteen))
+}
+
+// Nine mocks base method.
+func (m *MockBarAliasTString[T]) Nine(arg0 generics.Iface[T]) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Nine", arg0)
+}
+
+// Nine indicates an expected call of Nine.
+func (mr *MockBarAliasTStringMockRecorder[T]) Nine(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBarAliasTString[T])(nil).Nine), arg0)
+}
+
+// Nineteen mocks base method.
+func (m *MockBarAliasTString[T]) Nineteen() generics.AliasType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nineteen")
+	ret0, _ := ret[0].(generics.AliasType)
+	return ret0
+}
+
+// Nineteen indicates an expected call of Nineteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Nineteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Nineteen))
+}
+
+// One mocks base method.
+func (m *MockBarAliasTString[T]) One(arg0 string) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "One", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// One indicates an expected call of One.
+func (mr *MockBarAliasTStringMockRecorder[T]) One(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBarAliasTString[T])(nil).One), arg0)
+}
+
+// Seven mocks base method.
+func (m *MockBarAliasTString[T]) Seven(arg0 T) other.One[T] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seven", arg0)
+	ret0, _ := ret[0].(other.One[T])
+	return ret0
+}
+
+// Seven indicates an expected call of Seven.
+func (mr *MockBarAliasTStringMockRecorder[T]) Seven(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBarAliasTString[T])(nil).Seven), arg0)
+}
+
+// Seventeen mocks base method.
+func (m *MockBarAliasTString[T]) Seventeen() (*generics.Foo[other.Three, other.Four], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seventeen")
+	ret0, _ := ret[0].(*generics.Foo[other.Three, other.Four])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Seventeen indicates an expected call of Seventeen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Seventeen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Seventeen))
+}
+
+// Six mocks base method.
+func (m *MockBarAliasTString[T]) Six(arg0 T) *generics.Baz[T] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Six", arg0)
+	ret0, _ := ret[0].(*generics.Baz[T])
+	return ret0
+}
+
+// Six indicates an expected call of Six.
+func (mr *MockBarAliasTStringMockRecorder[T]) Six(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBarAliasTString[T])(nil).Six), arg0)
+}
+
+// Sixteen mocks base method.
+func (m *MockBarAliasTString[T]) Sixteen() (generics.Baz[other.Three], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sixteen")
+	ret0, _ := ret[0].(generics.Baz[other.Three])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Sixteen indicates an expected call of Sixteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Sixteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Sixteen))
+}
+
+// Ten mocks base method.
+func (m *MockBarAliasTString[T]) Ten(arg0 *T) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Ten", arg0)
+}
+
+// Ten indicates an expected call of Ten.
+func (mr *MockBarAliasTStringMockRecorder[T]) Ten(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBarAliasTString[T])(nil).Ten), arg0)
+}
+
+// Thirteen mocks base method.
+func (m *MockBarAliasTString[T]) Thirteen() (generics.Baz[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Thirteen")
+	ret0, _ := ret[0].(generics.Baz[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Thirteen indicates an expected call of Thirteen.
+func (mr *MockBarAliasTStringMockRecorder[T]) Thirteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBarAliasTString[T])(nil).Thirteen))
+}
+
+// Three mocks base method.
+func (m *MockBarAliasTString[T]) Three(arg0 T) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Three", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Three indicates an expected call of Three.
+func (mr *MockBarAliasTStringMockRecorder[T]) Three(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBarAliasTString[T])(nil).Three), arg0)
+}
+
+// Twelve mocks base method.
+func (m *MockBarAliasTString[T]) Twelve() (*other.Two[T, string], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Twelve")
+	ret0, _ := ret[0].(*other.Two[T, string])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Twelve indicates an expected call of Twelve.
+func (mr *MockBarAliasTStringMockRecorder[T]) Twelve() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBarAliasTString[T])(nil).Twelve))
+}
+
+// Two mocks base method.
+func (m *MockBarAliasTString[T]) Two(arg0 T) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Two", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Two indicates an expected call of Two.
+func (mr *MockBarAliasTStringMockRecorder[T]) Two(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBarAliasTString[T])(nil).Two), arg0)
+}
+
+// MockBarAliasIntR is a mock of BarAliasIntR interface.
+type MockBarAliasIntR[Q any] struct {
+	ctrl     *gomock.Controller
+	recorder *MockBarAliasIntRMockRecorder[Q]
+	isgomock struct{}
+}
+
+// MockBarAliasIntRMockRecorder is the mock recorder for MockBarAliasIntR.
+type MockBarAliasIntRMockRecorder[Q any] struct {
+	mock *MockBarAliasIntR[Q]
+}
+
+// NewMockBarAliasIntR creates a new mock instance.
+func NewMockBarAliasIntR[Q any](ctrl *gomock.Controller) *MockBarAliasIntR[Q] {
+	mock := &MockBarAliasIntR[Q]{ctrl: ctrl}
+	mock.recorder = &MockBarAliasIntRMockRecorder[Q]{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBarAliasIntR[Q]) EXPECT() *MockBarAliasIntRMockRecorder[Q] {
+	return m.recorder
+}
+
+// Eight mocks base method.
+func (m *MockBarAliasIntR[Q]) Eight(arg0 int) other.Two[int, Q] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eight", arg0)
+	ret0, _ := ret[0].(other.Two[int, Q])
+	return ret0
+}
+
+// Eight indicates an expected call of Eight.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Eight(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Eight), arg0)
+}
+
+// Eighteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Eighteen() (generics.Iface[*other.Five], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eighteen")
+	ret0, _ := ret[0].(generics.Iface[*other.Five])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eighteen indicates an expected call of Eighteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Eighteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Eighteen))
+}
+
+// Eleven mocks base method.
+func (m *MockBarAliasIntR[Q]) Eleven() (*other.One[int], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eleven")
+	ret0, _ := ret[0].(*other.One[int])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eleven indicates an expected call of Eleven.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Eleven() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Eleven))
+}
+
+// Fifteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Fifteen() (generics.Iface[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fifteen")
+	ret0, _ := ret[0].(generics.Iface[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fifteen indicates an expected call of Fifteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Fifteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Fifteen))
+}
+
+// Five mocks base method.
+func (m *MockBarAliasIntR[Q]) Five(arg0 int) generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Five", arg0)
+	ret0, _ := ret[0].(generics.Baz[int])
+	return ret0
+}
+
+// Five indicates an expected call of Five.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Five(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Five), arg0)
+}
+
+// Four mocks base method.
+func (m *MockBarAliasIntR[Q]) Four(arg0 int) generics.Foo[int, Q] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Four", arg0)
+	ret0, _ := ret[0].(generics.Foo[int, Q])
+	return ret0
+}
+
+// Four indicates an expected call of Four.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Four(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Four), arg0)
+}
+
+// Fourteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Fourteen() (*generics.Foo[generics.StructType, generics.StructType2], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fourteen")
+	ret0, _ := ret[0].(*generics.Foo[generics.StructType, generics.StructType2])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fourteen indicates an expected call of Fourteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Fourteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Fourteen))
+}
+
+// Nine mocks base method.
+func (m *MockBarAliasIntR[Q]) Nine(arg0 generics.Iface[int]) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Nine", arg0)
+}
+
+// Nine indicates an expected call of Nine.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Nine(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Nine), arg0)
+}
+
+// Nineteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Nineteen() generics.AliasType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nineteen")
+	ret0, _ := ret[0].(generics.AliasType)
+	return ret0
+}
+
+// Nineteen indicates an expected call of Nineteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Nineteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Nineteen))
+}
+
+// One mocks base method.
+func (m *MockBarAliasIntR[Q]) One(arg0 string) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "One", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// One indicates an expected call of One.
+func (mr *MockBarAliasIntRMockRecorder[Q]) One(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).One), arg0)
+}
+
+// Seven mocks base method.
+func (m *MockBarAliasIntR[Q]) Seven(arg0 int) other.One[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seven", arg0)
+	ret0, _ := ret[0].(other.One[int])
+	return ret0
+}
+
+// Seven indicates an expected call of Seven.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Seven(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Seven), arg0)
+}
+
+// Seventeen mocks base method.
+func (m *MockBarAliasIntR[Q]) Seventeen() (*generics.Foo[other.Three, other.Four], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seventeen")
+	ret0, _ := ret[0].(*generics.Foo[other.Three, other.Four])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Seventeen indicates an expected call of Seventeen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Seventeen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Seventeen))
+}
+
+// Six mocks base method.
+func (m *MockBarAliasIntR[Q]) Six(arg0 int) *generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Six", arg0)
+	ret0, _ := ret[0].(*generics.Baz[int])
+	return ret0
+}
+
+// Six indicates an expected call of Six.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Six(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Six), arg0)
+}
+
+// Sixteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Sixteen() (generics.Baz[other.Three], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sixteen")
+	ret0, _ := ret[0].(generics.Baz[other.Three])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Sixteen indicates an expected call of Sixteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Sixteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Sixteen))
+}
+
+// Ten mocks base method.
+func (m *MockBarAliasIntR[Q]) Ten(arg0 *int) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Ten", arg0)
+}
+
+// Ten indicates an expected call of Ten.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Ten(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Ten), arg0)
+}
+
+// Thirteen mocks base method.
+func (m *MockBarAliasIntR[Q]) Thirteen() (generics.Baz[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Thirteen")
+	ret0, _ := ret[0].(generics.Baz[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Thirteen indicates an expected call of Thirteen.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Thirteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Thirteen))
+}
+
+// Three mocks base method.
+func (m *MockBarAliasIntR[Q]) Three(arg0 int) Q {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Three", arg0)
+	ret0, _ := ret[0].(Q)
+	return ret0
+}
+
+// Three indicates an expected call of Three.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Three(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Three), arg0)
+}
+
+// Twelve mocks base method.
+func (m *MockBarAliasIntR[Q]) Twelve() (*other.Two[int, Q], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Twelve")
+	ret0, _ := ret[0].(*other.Two[int, Q])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Twelve indicates an expected call of Twelve.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Twelve() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Twelve))
+}
+
+// Two mocks base method.
+func (m *MockBarAliasIntR[Q]) Two(arg0 int) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Two", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Two indicates an expected call of Two.
+func (mr *MockBarAliasIntRMockRecorder[Q]) Two(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBarAliasIntR[Q])(nil).Two), arg0)
+}
+
+// MockBarAliasIntBazR is a mock of BarAliasIntBazR interface.
+type MockBarAliasIntBazR[Q any] struct {
+	ctrl     *gomock.Controller
+	recorder *MockBarAliasIntBazRMockRecorder[Q]
+	isgomock struct{}
+}
+
+// MockBarAliasIntBazRMockRecorder is the mock recorder for MockBarAliasIntBazR.
+type MockBarAliasIntBazRMockRecorder[Q any] struct {
+	mock *MockBarAliasIntBazR[Q]
+}
+
+// NewMockBarAliasIntBazR creates a new mock instance.
+func NewMockBarAliasIntBazR[Q any](ctrl *gomock.Controller) *MockBarAliasIntBazR[Q] {
+	mock := &MockBarAliasIntBazR[Q]{ctrl: ctrl}
+	mock.recorder = &MockBarAliasIntBazRMockRecorder[Q]{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBarAliasIntBazR[Q]) EXPECT() *MockBarAliasIntBazRMockRecorder[Q] {
+	return m.recorder
+}
+
+// Eight mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Eight(arg0 int) other.Two[int, generics.Baz[Q]] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eight", arg0)
+	ret0, _ := ret[0].(other.Two[int, generics.Baz[Q]])
+	return ret0
+}
+
+// Eight indicates an expected call of Eight.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Eight(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Eight), arg0)
+}
+
+// Eighteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Eighteen() (generics.Iface[*other.Five], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eighteen")
+	ret0, _ := ret[0].(generics.Iface[*other.Five])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eighteen indicates an expected call of Eighteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Eighteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Eighteen))
+}
+
+// Eleven mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Eleven() (*other.One[int], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eleven")
+	ret0, _ := ret[0].(*other.One[int])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eleven indicates an expected call of Eleven.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Eleven() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Eleven))
+}
+
+// Fifteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Fifteen() (generics.Iface[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fifteen")
+	ret0, _ := ret[0].(generics.Iface[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fifteen indicates an expected call of Fifteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Fifteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Fifteen))
+}
+
+// Five mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Five(arg0 int) generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Five", arg0)
+	ret0, _ := ret[0].(generics.Baz[int])
+	return ret0
+}
+
+// Five indicates an expected call of Five.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Five(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Five), arg0)
+}
+
+// Four mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Four(arg0 int) generics.Foo[int, generics.Baz[Q]] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Four", arg0)
+	ret0, _ := ret[0].(generics.Foo[int, generics.Baz[Q]])
+	return ret0
+}
+
+// Four indicates an expected call of Four.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Four(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Four), arg0)
+}
+
+// Fourteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Fourteen() (*generics.Foo[generics.StructType, generics.StructType2], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fourteen")
+	ret0, _ := ret[0].(*generics.Foo[generics.StructType, generics.StructType2])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fourteen indicates an expected call of Fourteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Fourteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Fourteen))
+}
+
+// Nine mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Nine(arg0 generics.Iface[int]) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Nine", arg0)
+}
+
+// Nine indicates an expected call of Nine.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Nine(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Nine), arg0)
+}
+
+// Nineteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Nineteen() generics.AliasType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nineteen")
+	ret0, _ := ret[0].(generics.AliasType)
+	return ret0
+}
+
+// Nineteen indicates an expected call of Nineteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Nineteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Nineteen))
+}
+
+// One mocks base method.
+func (m *MockBarAliasIntBazR[Q]) One(arg0 string) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "One", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// One indicates an expected call of One.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) One(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).One), arg0)
+}
+
+// Seven mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Seven(arg0 int) other.One[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seven", arg0)
+	ret0, _ := ret[0].(other.One[int])
+	return ret0
+}
+
+// Seven indicates an expected call of Seven.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Seven(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Seven), arg0)
+}
+
+// Seventeen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Seventeen() (*generics.Foo[other.Three, other.Four], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seventeen")
+	ret0, _ := ret[0].(*generics.Foo[other.Three, other.Four])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Seventeen indicates an expected call of Seventeen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Seventeen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Seventeen))
+}
+
+// Six mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Six(arg0 int) *generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Six", arg0)
+	ret0, _ := ret[0].(*generics.Baz[int])
+	return ret0
+}
+
+// Six indicates an expected call of Six.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Six(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Six), arg0)
+}
+
+// Sixteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Sixteen() (generics.Baz[other.Three], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sixteen")
+	ret0, _ := ret[0].(generics.Baz[other.Three])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Sixteen indicates an expected call of Sixteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Sixteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Sixteen))
+}
+
+// Ten mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Ten(arg0 *int) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Ten", arg0)
+}
+
+// Ten indicates an expected call of Ten.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Ten(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Ten), arg0)
+}
+
+// Thirteen mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Thirteen() (generics.Baz[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Thirteen")
+	ret0, _ := ret[0].(generics.Baz[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Thirteen indicates an expected call of Thirteen.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Thirteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Thirteen))
+}
+
+// Three mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Three(arg0 int) generics.Baz[Q] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Three", arg0)
+	ret0, _ := ret[0].(generics.Baz[Q])
+	return ret0
+}
+
+// Three indicates an expected call of Three.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Three(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Three), arg0)
+}
+
+// Twelve mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Twelve() (*other.Two[int, generics.Baz[Q]], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Twelve")
+	ret0, _ := ret[0].(*other.Two[int, generics.Baz[Q]])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Twelve indicates an expected call of Twelve.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Twelve() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Twelve))
+}
+
+// Two mocks base method.
+func (m *MockBarAliasIntBazR[Q]) Two(arg0 int) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Two", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Two indicates an expected call of Two.
+func (mr *MockBarAliasIntBazRMockRecorder[Q]) Two(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBarAliasIntBazR[Q])(nil).Two), arg0)
+}
+
+// MockBarAliasIntBazString is a mock of BarAliasIntBazString interface.
+type MockBarAliasIntBazString struct {
+	ctrl     *gomock.Controller
+	recorder *MockBarAliasIntBazStringMockRecorder
+	isgomock struct{}
+}
+
+// MockBarAliasIntBazStringMockRecorder is the mock recorder for MockBarAliasIntBazString.
+type MockBarAliasIntBazStringMockRecorder struct {
+	mock *MockBarAliasIntBazString
+}
+
+// NewMockBarAliasIntBazString creates a new mock instance.
+func NewMockBarAliasIntBazString(ctrl *gomock.Controller) *MockBarAliasIntBazString {
+	mock := &MockBarAliasIntBazString{ctrl: ctrl}
+	mock.recorder = &MockBarAliasIntBazStringMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBarAliasIntBazString) EXPECT() *MockBarAliasIntBazStringMockRecorder {
+	return m.recorder
+}
+
+// Eight mocks base method.
+func (m *MockBarAliasIntBazString) Eight(arg0 int) other.Two[int, generics.Baz[string]] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eight", arg0)
+	ret0, _ := ret[0].(other.Two[int, generics.Baz[string]])
+	return ret0
+}
+
+// Eight indicates an expected call of Eight.
+func (mr *MockBarAliasIntBazStringMockRecorder) Eight(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Eight), arg0)
+}
+
+// Eighteen mocks base method.
+func (m *MockBarAliasIntBazString) Eighteen() (generics.Iface[*other.Five], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eighteen")
+	ret0, _ := ret[0].(generics.Iface[*other.Five])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eighteen indicates an expected call of Eighteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Eighteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Eighteen))
+}
+
+// Eleven mocks base method.
+func (m *MockBarAliasIntBazString) Eleven() (*other.One[int], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eleven")
+	ret0, _ := ret[0].(*other.One[int])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eleven indicates an expected call of Eleven.
+func (mr *MockBarAliasIntBazStringMockRecorder) Eleven() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Eleven))
+}
+
+// Fifteen mocks base method.
+func (m *MockBarAliasIntBazString) Fifteen() (generics.Iface[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fifteen")
+	ret0, _ := ret[0].(generics.Iface[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fifteen indicates an expected call of Fifteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Fifteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Fifteen))
+}
+
+// Five mocks base method.
+func (m *MockBarAliasIntBazString) Five(arg0 int) generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Five", arg0)
+	ret0, _ := ret[0].(generics.Baz[int])
+	return ret0
+}
+
+// Five indicates an expected call of Five.
+func (mr *MockBarAliasIntBazStringMockRecorder) Five(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Five), arg0)
+}
+
+// Four mocks base method.
+func (m *MockBarAliasIntBazString) Four(arg0 int) generics.Foo[int, generics.Baz[string]] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Four", arg0)
+	ret0, _ := ret[0].(generics.Foo[int, generics.Baz[string]])
+	return ret0
+}
+
+// Four indicates an expected call of Four.
+func (mr *MockBarAliasIntBazStringMockRecorder) Four(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Four), arg0)
+}
+
+// Fourteen mocks base method.
+func (m *MockBarAliasIntBazString) Fourteen() (*generics.Foo[generics.StructType, generics.StructType2], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fourteen")
+	ret0, _ := ret[0].(*generics.Foo[generics.StructType, generics.StructType2])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fourteen indicates an expected call of Fourteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Fourteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Fourteen))
+}
+
+// Nine mocks base method.
+func (m *MockBarAliasIntBazString) Nine(arg0 generics.Iface[int]) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Nine", arg0)
+}
+
+// Nine indicates an expected call of Nine.
+func (mr *MockBarAliasIntBazStringMockRecorder) Nine(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Nine), arg0)
+}
+
+// Nineteen mocks base method.
+func (m *MockBarAliasIntBazString) Nineteen() generics.AliasType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nineteen")
+	ret0, _ := ret[0].(generics.AliasType)
+	return ret0
+}
+
+// Nineteen indicates an expected call of Nineteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Nineteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Nineteen))
+}
+
+// One mocks base method.
+func (m *MockBarAliasIntBazString) One(arg0 string) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "One", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// One indicates an expected call of One.
+func (mr *MockBarAliasIntBazStringMockRecorder) One(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBarAliasIntBazString)(nil).One), arg0)
+}
+
+// Seven mocks base method.
+func (m *MockBarAliasIntBazString) Seven(arg0 int) other.One[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seven", arg0)
+	ret0, _ := ret[0].(other.One[int])
+	return ret0
+}
+
+// Seven indicates an expected call of Seven.
+func (mr *MockBarAliasIntBazStringMockRecorder) Seven(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Seven), arg0)
+}
+
+// Seventeen mocks base method.
+func (m *MockBarAliasIntBazString) Seventeen() (*generics.Foo[other.Three, other.Four], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seventeen")
+	ret0, _ := ret[0].(*generics.Foo[other.Three, other.Four])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Seventeen indicates an expected call of Seventeen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Seventeen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Seventeen))
+}
+
+// Six mocks base method.
+func (m *MockBarAliasIntBazString) Six(arg0 int) *generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Six", arg0)
+	ret0, _ := ret[0].(*generics.Baz[int])
+	return ret0
+}
+
+// Six indicates an expected call of Six.
+func (mr *MockBarAliasIntBazStringMockRecorder) Six(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Six), arg0)
+}
+
+// Sixteen mocks base method.
+func (m *MockBarAliasIntBazString) Sixteen() (generics.Baz[other.Three], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sixteen")
+	ret0, _ := ret[0].(generics.Baz[other.Three])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Sixteen indicates an expected call of Sixteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Sixteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Sixteen))
+}
+
+// Ten mocks base method.
+func (m *MockBarAliasIntBazString) Ten(arg0 *int) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Ten", arg0)
+}
+
+// Ten indicates an expected call of Ten.
+func (mr *MockBarAliasIntBazStringMockRecorder) Ten(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Ten), arg0)
+}
+
+// Thirteen mocks base method.
+func (m *MockBarAliasIntBazString) Thirteen() (generics.Baz[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Thirteen")
+	ret0, _ := ret[0].(generics.Baz[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Thirteen indicates an expected call of Thirteen.
+func (mr *MockBarAliasIntBazStringMockRecorder) Thirteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Thirteen))
+}
+
+// Three mocks base method.
+func (m *MockBarAliasIntBazString) Three(arg0 int) generics.Baz[string] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Three", arg0)
+	ret0, _ := ret[0].(generics.Baz[string])
+	return ret0
+}
+
+// Three indicates an expected call of Three.
+func (mr *MockBarAliasIntBazStringMockRecorder) Three(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Three), arg0)
+}
+
+// Twelve mocks base method.
+func (m *MockBarAliasIntBazString) Twelve() (*other.Two[int, generics.Baz[string]], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Twelve")
+	ret0, _ := ret[0].(*other.Two[int, generics.Baz[string]])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Twelve indicates an expected call of Twelve.
+func (mr *MockBarAliasIntBazStringMockRecorder) Twelve() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Twelve))
+}
+
+// Two mocks base method.
+func (m *MockBarAliasIntBazString) Two(arg0 int) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Two", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Two indicates an expected call of Two.
+func (mr *MockBarAliasIntBazStringMockRecorder) Two(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBarAliasIntBazString)(nil).Two), arg0)
+}
diff --git a/mockgen/internal/tests/generics/package_mode/mock_test.go b/mockgen/internal/tests/generics/package_mode/mock_test.go
index 6a4858b3..9075b0a1 100644
--- a/mockgen/internal/tests/generics/package_mode/mock_test.go
+++ b/mockgen/internal/tests/generics/package_mode/mock_test.go
@@ -1,9 +1,9 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: go.uber.org/mock/mockgen/internal/tests/generics (interfaces: Bar,Universe,MilkyWay,SolarSystem,Earth,Water)
+// Source: go.uber.org/mock/mockgen/internal/tests/generics (interfaces: Bar,BarAliasIntString,Universe,MilkyWay,SolarSystem,Earth,Water)
 //
 // Generated by this command:
 //
-//	mockgen --destination=package_mode/mock_test.go --package=package_mode . Bar,Universe,MilkyWay,SolarSystem,Earth,Water
+//	mockgen --destination=package_mode/mock_test.go --package=package_mode . Bar,BarAliasIntString,Universe,MilkyWay,SolarSystem,Earth,Water
 //
 
 // Package package_mode is a generated GoMock package.
@@ -312,6 +312,300 @@ func (mr *MockBarMockRecorder[T, R]) Two(arg0 any) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBar[T, R])(nil).Two), arg0)
 }
 
+// MockBarAliasIntString is a mock of BarAliasIntString interface.
+type MockBarAliasIntString struct {
+	ctrl     *gomock.Controller
+	recorder *MockBarAliasIntStringMockRecorder
+	isgomock struct{}
+}
+
+// MockBarAliasIntStringMockRecorder is the mock recorder for MockBarAliasIntString.
+type MockBarAliasIntStringMockRecorder struct {
+	mock *MockBarAliasIntString
+}
+
+// NewMockBarAliasIntString creates a new mock instance.
+func NewMockBarAliasIntString(ctrl *gomock.Controller) *MockBarAliasIntString {
+	mock := &MockBarAliasIntString{ctrl: ctrl}
+	mock.recorder = &MockBarAliasIntStringMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBarAliasIntString) EXPECT() *MockBarAliasIntStringMockRecorder {
+	return m.recorder
+}
+
+// Eight mocks base method.
+func (m *MockBarAliasIntString) Eight(arg0 int) other.Two[int, string] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eight", arg0)
+	ret0, _ := ret[0].(other.Two[int, string])
+	return ret0
+}
+
+// Eight indicates an expected call of Eight.
+func (mr *MockBarAliasIntStringMockRecorder) Eight(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBarAliasIntString)(nil).Eight), arg0)
+}
+
+// Eighteen mocks base method.
+func (m *MockBarAliasIntString) Eighteen() (generics.Iface[*other.Five], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eighteen")
+	ret0, _ := ret[0].(generics.Iface[*other.Five])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eighteen indicates an expected call of Eighteen.
+func (mr *MockBarAliasIntStringMockRecorder) Eighteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Eighteen))
+}
+
+// Eleven mocks base method.
+func (m *MockBarAliasIntString) Eleven() (*other.One[int], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Eleven")
+	ret0, _ := ret[0].(*other.One[int])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Eleven indicates an expected call of Eleven.
+func (mr *MockBarAliasIntStringMockRecorder) Eleven() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBarAliasIntString)(nil).Eleven))
+}
+
+// Fifteen mocks base method.
+func (m *MockBarAliasIntString) Fifteen() (generics.Iface[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fifteen")
+	ret0, _ := ret[0].(generics.Iface[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fifteen indicates an expected call of Fifteen.
+func (mr *MockBarAliasIntStringMockRecorder) Fifteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Fifteen))
+}
+
+// Five mocks base method.
+func (m *MockBarAliasIntString) Five(arg0 int) generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Five", arg0)
+	ret0, _ := ret[0].(generics.Baz[int])
+	return ret0
+}
+
+// Five indicates an expected call of Five.
+func (mr *MockBarAliasIntStringMockRecorder) Five(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBarAliasIntString)(nil).Five), arg0)
+}
+
+// Four mocks base method.
+func (m *MockBarAliasIntString) Four(arg0 int) generics.Foo[int, string] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Four", arg0)
+	ret0, _ := ret[0].(generics.Foo[int, string])
+	return ret0
+}
+
+// Four indicates an expected call of Four.
+func (mr *MockBarAliasIntStringMockRecorder) Four(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBarAliasIntString)(nil).Four), arg0)
+}
+
+// Fourteen mocks base method.
+func (m *MockBarAliasIntString) Fourteen() (*generics.Foo[generics.StructType, generics.StructType2], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Fourteen")
+	ret0, _ := ret[0].(*generics.Foo[generics.StructType, generics.StructType2])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Fourteen indicates an expected call of Fourteen.
+func (mr *MockBarAliasIntStringMockRecorder) Fourteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Fourteen))
+}
+
+// Nine mocks base method.
+func (m *MockBarAliasIntString) Nine(arg0 generics.Iface[int]) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Nine", arg0)
+}
+
+// Nine indicates an expected call of Nine.
+func (mr *MockBarAliasIntStringMockRecorder) Nine(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBarAliasIntString)(nil).Nine), arg0)
+}
+
+// Nineteen mocks base method.
+func (m *MockBarAliasIntString) Nineteen() generics.AliasType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Nineteen")
+	ret0, _ := ret[0].(generics.AliasType)
+	return ret0
+}
+
+// Nineteen indicates an expected call of Nineteen.
+func (mr *MockBarAliasIntStringMockRecorder) Nineteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Nineteen))
+}
+
+// One mocks base method.
+func (m *MockBarAliasIntString) One(arg0 string) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "One", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// One indicates an expected call of One.
+func (mr *MockBarAliasIntStringMockRecorder) One(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBarAliasIntString)(nil).One), arg0)
+}
+
+// Seven mocks base method.
+func (m *MockBarAliasIntString) Seven(arg0 int) other.One[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seven", arg0)
+	ret0, _ := ret[0].(other.One[int])
+	return ret0
+}
+
+// Seven indicates an expected call of Seven.
+func (mr *MockBarAliasIntStringMockRecorder) Seven(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBarAliasIntString)(nil).Seven), arg0)
+}
+
+// Seventeen mocks base method.
+func (m *MockBarAliasIntString) Seventeen() (*generics.Foo[other.Three, other.Four], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seventeen")
+	ret0, _ := ret[0].(*generics.Foo[other.Three, other.Four])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Seventeen indicates an expected call of Seventeen.
+func (mr *MockBarAliasIntStringMockRecorder) Seventeen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBarAliasIntString)(nil).Seventeen))
+}
+
+// Six mocks base method.
+func (m *MockBarAliasIntString) Six(arg0 int) *generics.Baz[int] {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Six", arg0)
+	ret0, _ := ret[0].(*generics.Baz[int])
+	return ret0
+}
+
+// Six indicates an expected call of Six.
+func (mr *MockBarAliasIntStringMockRecorder) Six(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBarAliasIntString)(nil).Six), arg0)
+}
+
+// Sixteen mocks base method.
+func (m *MockBarAliasIntString) Sixteen() (generics.Baz[other.Three], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sixteen")
+	ret0, _ := ret[0].(generics.Baz[other.Three])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Sixteen indicates an expected call of Sixteen.
+func (mr *MockBarAliasIntStringMockRecorder) Sixteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Sixteen))
+}
+
+// Ten mocks base method.
+func (m *MockBarAliasIntString) Ten(arg0 *int) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Ten", arg0)
+}
+
+// Ten indicates an expected call of Ten.
+func (mr *MockBarAliasIntStringMockRecorder) Ten(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBarAliasIntString)(nil).Ten), arg0)
+}
+
+// Thirteen mocks base method.
+func (m *MockBarAliasIntString) Thirteen() (generics.Baz[generics.StructType], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Thirteen")
+	ret0, _ := ret[0].(generics.Baz[generics.StructType])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Thirteen indicates an expected call of Thirteen.
+func (mr *MockBarAliasIntStringMockRecorder) Thirteen() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBarAliasIntString)(nil).Thirteen))
+}
+
+// Three mocks base method.
+func (m *MockBarAliasIntString) Three(arg0 int) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Three", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Three indicates an expected call of Three.
+func (mr *MockBarAliasIntStringMockRecorder) Three(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBarAliasIntString)(nil).Three), arg0)
+}
+
+// Twelve mocks base method.
+func (m *MockBarAliasIntString) Twelve() (*other.Two[int, string], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Twelve")
+	ret0, _ := ret[0].(*other.Two[int, string])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Twelve indicates an expected call of Twelve.
+func (mr *MockBarAliasIntStringMockRecorder) Twelve() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBarAliasIntString)(nil).Twelve))
+}
+
+// Two mocks base method.
+func (m *MockBarAliasIntString) Two(arg0 int) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Two", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Two indicates an expected call of Two.
+func (mr *MockBarAliasIntStringMockRecorder) Two(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBarAliasIntString)(nil).Two), arg0)
+}
+
 // MockUniverse is a mock of Universe interface.
 type MockUniverse[T constraints.Signed] struct {
 	ctrl     *gomock.Controller
diff --git a/mockgen/package_mode.go b/mockgen/package_mode.go
index 29fab7f8..6526b8d8 100644
--- a/mockgen/package_mode.go
+++ b/mockgen/package_mode.go
@@ -129,9 +129,27 @@ func (p *packageModeParser) parseInterface(obj types.Object) (*model.Interface,
 		return &model.Interface{Name: obj.Name(), Methods: methods}, nil
 	}
 
-	typeParams := make([]*model.Parameter, named.TypeParams().Len())
-	for i := range named.TypeParams().Len() {
-		param := named.TypeParams().At(i)
+	var requiredTypeParams *types.TypeParamList
+	// If the named type is an instance of a generic, it must be from an alias.
+	if rootAlias, ok := obj.Type().(*types.Alias); ok && named.TypeArgs() != nil {
+		if rootAlias.TypeParams() == nil {
+			// If the root alias is not generic, then we can treat this like any
+			// other interface. The named interface is a complete type.
+			return &model.Interface{Name: obj.Name(), Methods: methods}, nil
+		}
+		// If the root alias is generic, then the type parameters that are needed
+		// are that of the generic alias. The right-hand-side of an alias must
+		// be a complete type. For the generic type Y[Z any], this is not a valid
+		// type alias `type X = Y`.
+		requiredTypeParams = rootAlias.TypeParams()
+	}
+	if requiredTypeParams == nil {
+		requiredTypeParams = named.TypeParams()
+	}
+
+	typeParams := make([]*model.Parameter, requiredTypeParams.Len())
+	for i := range requiredTypeParams.Len() {
+		param := requiredTypeParams.At(i)
 		typeParam, err := p.parseConstraint(param)
 		if err != nil {
 			return nil, newParseTypeError("parse type parameter", param.String(), err)