diff --git a/applicationset/controllers/applicationset_controller_test.go b/applicationset/controllers/applicationset_controller_test.go
index b89d95d671403..bcd048cfc44e8 100644
--- a/applicationset/controllers/applicationset_controller_test.go
+++ b/applicationset/controllers/applicationset_controller_test.go
@@ -31,7 +31,6 @@ import (
 	"github.com/argoproj/gitops-engine/pkg/sync/common"
 
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
-	argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	appclientset "github.com/argoproj/argo-cd/v2/pkg/client/clientset/versioned/fake"
 	"github.com/argoproj/argo-cd/v2/util/collections"
 	dbmocks "github.com/argoproj/argo-cd/v2/util/db/mocks"
@@ -41,13 +40,13 @@ type generatorMock struct {
 	mock.Mock
 }
 
-func (g *generatorMock) GetTemplate(appSetGenerator *argov1alpha1.ApplicationSetGenerator) *argov1alpha1.ApplicationSetTemplate {
+func (g *generatorMock) GetTemplate(appSetGenerator *v1alpha1.ApplicationSetGenerator) *v1alpha1.ApplicationSetTemplate {
 	args := g.Called(appSetGenerator)
 
-	return args.Get(0).(*argov1alpha1.ApplicationSetTemplate)
+	return args.Get(0).(*v1alpha1.ApplicationSetTemplate)
 }
 
-func (g *generatorMock) GenerateParams(appSetGenerator *argov1alpha1.ApplicationSetGenerator, _ *argov1alpha1.ApplicationSet) ([]map[string]interface{}, error) {
+func (g *generatorMock) GenerateParams(appSetGenerator *v1alpha1.ApplicationSetGenerator, _ *v1alpha1.ApplicationSet) ([]map[string]interface{}, error) {
 	args := g.Called(appSetGenerator)
 
 	return args.Get(0).([]map[string]interface{}), args.Error(1)
@@ -57,35 +56,35 @@ type rendererMock struct {
 	mock.Mock
 }
 
-func (g *generatorMock) GetRequeueAfter(appSetGenerator *argov1alpha1.ApplicationSetGenerator) time.Duration {
+func (g *generatorMock) GetRequeueAfter(appSetGenerator *v1alpha1.ApplicationSetGenerator) time.Duration {
 	args := g.Called(appSetGenerator)
 
 	return args.Get(0).(time.Duration)
 }
 
-func (r *rendererMock) RenderTemplateParams(tmpl *argov1alpha1.Application, syncPolicy *argov1alpha1.ApplicationSetSyncPolicy, params map[string]interface{}, useGoTemplate bool) (*argov1alpha1.Application, error) {
+func (r *rendererMock) RenderTemplateParams(tmpl *v1alpha1.Application, syncPolicy *v1alpha1.ApplicationSetSyncPolicy, params map[string]interface{}, useGoTemplate bool) (*v1alpha1.Application, error) {
 	args := r.Called(tmpl, params, useGoTemplate)
 
 	if args.Error(1) != nil {
 		return nil, args.Error(1)
 	}
 
-	return args.Get(0).(*argov1alpha1.Application), args.Error(1)
+	return args.Get(0).(*v1alpha1.Application), args.Error(1)
 
 }
 
 func TestExtractApplications(t *testing.T) {
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
 		name                string
 		params              []map[string]interface{}
-		template            argov1alpha1.ApplicationSetTemplate
+		template            v1alpha1.ApplicationSetTemplate
 		generateParamsError error
 		rendererError       error
 		expectErr           bool
@@ -94,13 +93,13 @@ func TestExtractApplications(t *testing.T) {
 		{
 			name:   "Generate two applications",
 			params: []map[string]interface{}{{"name": "app1"}, {"name": "app2"}},
-			template: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			template: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:      "name",
 					Namespace: "namespace",
 					Labels:    map[string]string{"label_name": "label_value"},
 				},
-				Spec: argov1alpha1.ApplicationSpec{},
+				Spec: v1alpha1.ApplicationSpec{},
 			},
 			expectedReason: "",
 		},
@@ -113,13 +112,13 @@ func TestExtractApplications(t *testing.T) {
 		{
 			name:   "Handles error from the render",
 			params: []map[string]interface{}{{"name": "app1"}, {"name": "app2"}},
-			template: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			template: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:      "name",
 					Namespace: "namespace",
 					Labels:    map[string]string{"label_name": "label_value"},
 				},
-				Spec: argov1alpha1.ApplicationSpec{},
+				Spec: v1alpha1.ApplicationSpec{},
 			},
 			rendererError:  fmt.Errorf("error"),
 			expectErr:      true,
@@ -127,7 +126,7 @@ func TestExtractApplications(t *testing.T) {
 		},
 	} {
 		cc := c
-		app := argov1alpha1.Application{
+		app := v1alpha1.Application{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: "test",
 			},
@@ -135,7 +134,7 @@ func TestExtractApplications(t *testing.T) {
 
 		t.Run(cc.name, func(t *testing.T) {
 
-			appSet := &argov1alpha1.ApplicationSet{
+			appSet := &v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
@@ -145,19 +144,19 @@ func TestExtractApplications(t *testing.T) {
 			client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(appSet).Build()
 
 			generatorMock := generatorMock{}
-			generator := argov1alpha1.ApplicationSetGenerator{
-				List: &argov1alpha1.ListGenerator{},
+			generator := v1alpha1.ApplicationSetGenerator{
+				List: &v1alpha1.ListGenerator{},
 			}
 
 			generatorMock.On("GenerateParams", &generator).
 				Return(cc.params, cc.generateParamsError)
 
 			generatorMock.On("GetTemplate", &generator).
-				Return(&argov1alpha1.ApplicationSetTemplate{})
+				Return(&v1alpha1.ApplicationSetTemplate{})
 
 			rendererMock := rendererMock{}
 
-			var expectedApps []argov1alpha1.Application
+			var expectedApps []v1alpha1.Application
 
 			if cc.generateParamsError == nil {
 				for _, p := range cc.params {
@@ -184,13 +183,13 @@ func TestExtractApplications(t *testing.T) {
 				KubeClientset: kubefake.NewSimpleClientset(),
 			}
 
-			got, reason, err := r.generateApplications(argov1alpha1.ApplicationSet{
+			got, reason, err := r.generateApplications(v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Generators: []argov1alpha1.ApplicationSetGenerator{generator},
+				Spec: v1alpha1.ApplicationSetSpec{
+					Generators: []v1alpha1.ApplicationSetGenerator{generator},
 					Template:   cc.template,
 				},
 			})
@@ -215,53 +214,53 @@ func TestExtractApplications(t *testing.T) {
 
 func TestMergeTemplateApplications(t *testing.T) {
 	scheme := runtime.NewScheme()
-	_ = argov1alpha1.AddToScheme(scheme)
-	_ = argov1alpha1.AddToScheme(scheme)
+	_ = v1alpha1.AddToScheme(scheme)
+	_ = v1alpha1.AddToScheme(scheme)
 
 	client := fake.NewClientBuilder().WithScheme(scheme).Build()
 
 	for _, c := range []struct {
 		name             string
 		params           []map[string]interface{}
-		template         argov1alpha1.ApplicationSetTemplate
-		overrideTemplate argov1alpha1.ApplicationSetTemplate
-		expectedMerged   argov1alpha1.ApplicationSetTemplate
-		expectedApps     []argov1alpha1.Application
+		template         v1alpha1.ApplicationSetTemplate
+		overrideTemplate v1alpha1.ApplicationSetTemplate
+		expectedMerged   v1alpha1.ApplicationSetTemplate
+		expectedApps     []v1alpha1.Application
 	}{
 		{
 			name:   "Generate app",
 			params: []map[string]interface{}{{"name": "app1"}},
-			template: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			template: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:      "name",
 					Namespace: "namespace",
 					Labels:    map[string]string{"label_name": "label_value"},
 				},
-				Spec: argov1alpha1.ApplicationSpec{},
+				Spec: v1alpha1.ApplicationSpec{},
 			},
-			overrideTemplate: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			overrideTemplate: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:   "test",
 					Labels: map[string]string{"foo": "bar"},
 				},
-				Spec: argov1alpha1.ApplicationSpec{},
+				Spec: v1alpha1.ApplicationSpec{},
 			},
-			expectedMerged: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			expectedMerged: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:      "test",
 					Namespace: "namespace",
 					Labels:    map[string]string{"label_name": "label_value", "foo": "bar"},
 				},
-				Spec: argov1alpha1.ApplicationSpec{},
+				Spec: v1alpha1.ApplicationSpec{},
 			},
-			expectedApps: []argov1alpha1.Application{
+			expectedApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      "test",
 						Namespace: "test",
 						Labels:    map[string]string{"foo": "bar"},
 					},
-					Spec: argov1alpha1.ApplicationSpec{},
+					Spec: v1alpha1.ApplicationSpec{},
 				},
 			},
 		},
@@ -271,8 +270,8 @@ func TestMergeTemplateApplications(t *testing.T) {
 		t.Run(cc.name, func(t *testing.T) {
 
 			generatorMock := generatorMock{}
-			generator := argov1alpha1.ApplicationSetGenerator{
-				List: &argov1alpha1.ListGenerator{},
+			generator := v1alpha1.ApplicationSetGenerator{
+				List: &v1alpha1.ListGenerator{},
 			}
 
 			generatorMock.On("GenerateParams", &generator).
@@ -297,13 +296,13 @@ func TestMergeTemplateApplications(t *testing.T) {
 				KubeClientset: kubefake.NewSimpleClientset(),
 			}
 
-			got, _, _ := r.generateApplications(argov1alpha1.ApplicationSet{
+			got, _, _ := r.generateApplications(v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Generators: []argov1alpha1.ApplicationSetGenerator{generator},
+				Spec: v1alpha1.ApplicationSetSpec{
+					Generators: []v1alpha1.ApplicationSetGenerator{generator},
 					Template:   cc.template,
 				},
 			},
@@ -318,41 +317,41 @@ func TestMergeTemplateApplications(t *testing.T) {
 func TestCreateOrUpdateInCluster(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
 		// name is human-readable test name
 		name string
 		// appSet is the ApplicationSet we are generating resources for
-		appSet argov1alpha1.ApplicationSet
+		appSet v1alpha1.ApplicationSet
 		// existingApps are the apps that already exist on the cluster
-		existingApps []argov1alpha1.Application
+		existingApps []v1alpha1.Application
 		// desiredApps are the generated apps to create/update
-		desiredApps []argov1alpha1.Application
+		desiredApps []v1alpha1.Application
 		// expected is what we expect the cluster Applications to look like, after createOrUpdateInCluster
-		expected []argov1alpha1.Application
+		expected []v1alpha1.Application
 	}{
 		{
 			name: "Create an app that doesn't exist",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
 			},
 			existingApps: nil,
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -368,20 +367,20 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 		},
 		{
 			name: "Update an existing app with a different project name",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -392,22 +391,22 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "test",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -418,7 +417,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "3",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -426,20 +425,20 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 		},
 		{
 			name: "Create a new app and check it doesn't replace the existing app",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -450,22 +449,22 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "test",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -476,7 +475,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -484,20 +483,20 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 		},
 		{
 			name: "Ensure that labels and annotations are added (via update) into an exiting application",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -508,24 +507,24 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:        "app1",
 						Labels:      map[string]string{"label-key": "label-value"},
 						Annotations: map[string]string{"annot-key": "annot-value"},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -538,7 +537,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Annotations:     map[string]string{"annot-key": "annot-value"},
 						ResourceVersion: "3",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -546,20 +545,20 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 		},
 		{
 			name: "Ensure that labels and annotations are removed from an existing app",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -572,22 +571,22 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Labels:          map[string]string{"label-key": "label-value"},
 						Annotations:     map[string]string{"annot-key": "annot-value"},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -598,7 +597,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "3",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -606,20 +605,20 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 		},
 		{
 			name: "Ensure that status and operation fields are not overridden by an update, when removing labels/annotations",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -632,28 +631,28 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Labels:          map[string]string{"label-key": "label-value"},
 						Annotations:     map[string]string{"annot-key": "annot-value"},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Resources: []argov1alpha1.ResourceStatus{{Name: "sample-name"}},
+					Status: v1alpha1.ApplicationStatus{
+						Resources: []v1alpha1.ResourceStatus{{Name: "sample-name"}},
 					},
-					Operation: &argov1alpha1.Operation{
-						Sync: &argov1alpha1.SyncOperation{Revision: "sample-revision"},
+					Operation: &v1alpha1.Operation{
+						Sync: &v1alpha1.SyncOperation{Revision: "sample-revision"},
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -664,36 +663,36 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "3",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Resources: []argov1alpha1.ResourceStatus{{Name: "sample-name"}},
+					Status: v1alpha1.ApplicationStatus{
+						Resources: []v1alpha1.ResourceStatus{{Name: "sample-name"}},
 					},
-					Operation: &argov1alpha1.Operation{
-						Sync: &argov1alpha1.SyncOperation{Revision: "sample-revision"},
+					Operation: &v1alpha1.Operation{
+						Sync: &v1alpha1.SyncOperation{Revision: "sample-revision"},
 					},
 				},
 			},
 		},
 		{
 			name: "Ensure that status and operation fields are not overridden by an update, when removing labels/annotations and adding other fields",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project:     "project",
-							Source:      &argov1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
-							Destination: argov1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
+							Source:      &v1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
+							Destination: v1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -704,32 +703,32 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Resources: []argov1alpha1.ResourceStatus{{Name: "sample-name"}},
+					Status: v1alpha1.ApplicationStatus{
+						Resources: []v1alpha1.ResourceStatus{{Name: "sample-name"}},
 					},
-					Operation: &argov1alpha1.Operation{
-						Sync: &argov1alpha1.SyncOperation{Revision: "sample-revision"},
+					Operation: &v1alpha1.Operation{
+						Sync: &v1alpha1.SyncOperation{Revision: "sample-revision"},
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:        "app1",
 						Labels:      map[string]string{"label-key": "label-value"},
 						Annotations: map[string]string{"annot-key": "annot-value"},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project:     "project",
-						Source:      &argov1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
-						Destination: argov1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
+						Source:      &v1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
+						Destination: v1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -742,36 +741,36 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Annotations:     map[string]string{"annot-key": "annot-value"},
 						ResourceVersion: "3",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project:     "project",
-						Source:      &argov1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
-						Destination: argov1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
+						Source:      &v1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
+						Destination: v1alpha1.ApplicationDestination{Server: "server", Namespace: "namespace"},
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Resources: []argov1alpha1.ResourceStatus{{Name: "sample-name"}},
+					Status: v1alpha1.ApplicationStatus{
+						Resources: []v1alpha1.ResourceStatus{{Name: "sample-name"}},
 					},
-					Operation: &argov1alpha1.Operation{
-						Sync: &argov1alpha1.SyncOperation{Revision: "sample-revision"},
+					Operation: &v1alpha1.Operation{
+						Sync: &v1alpha1.SyncOperation{Revision: "sample-revision"},
 					},
 				},
 			},
 		},
 		{
 			name: "Ensure that argocd notifications state and refresh annotation is preserved from an existing app",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -783,27 +782,27 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						ResourceVersion: "2",
 						Labels:          map[string]string{"label-key": "label-value"},
 						Annotations: map[string]string{
-							"annot-key":                       "annot-value",
-							NotifiedAnnotationKey:             `{"b620d4600c771a6f4cxxxxxxx:on-deployed:[0].y7b5sbwa2Q329JYHxxxxxx-fBs:slack:slack-test":1617144614}`,
-							argov1alpha1.AnnotationKeyRefresh: string(argov1alpha1.RefreshTypeNormal),
+							"annot-key":                   "annot-value",
+							NotifiedAnnotationKey:         `{"b620d4600c771a6f4cxxxxxxx:on-deployed:[0].y7b5sbwa2Q329JYHxxxxxx-fBs:slack:slack-test":1617144614}`,
+							v1alpha1.AnnotationKeyRefresh: string(v1alpha1.RefreshTypeNormal),
 						},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -814,34 +813,34 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "3",
 						Annotations: map[string]string{
-							NotifiedAnnotationKey:             `{"b620d4600c771a6f4cxxxxxxx:on-deployed:[0].y7b5sbwa2Q329JYHxxxxxx-fBs:slack:slack-test":1617144614}`,
-							argov1alpha1.AnnotationKeyRefresh: string(argov1alpha1.RefreshTypeNormal),
+							NotifiedAnnotationKey:         `{"b620d4600c771a6f4cxxxxxxx:on-deployed:[0].y7b5sbwa2Q329JYHxxxxxx-fBs:slack:slack-test":1617144614}`,
+							v1alpha1.AnnotationKeyRefresh: string(v1alpha1.RefreshTypeNormal),
 						},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
 		}, {
 			name: "Ensure that configured preserved annotations are preserved from an existing app",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
-					PreservedFields: &argov1alpha1.ApplicationPreservedFields{
+					PreservedFields: &v1alpha1.ApplicationPreservedFields{
 						Annotations: []string{"preserved-annot-key"},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -856,22 +855,22 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 							"preserved-annot-key": "preserved-annot-value",
 						},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -885,7 +884,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 							"preserved-annot-key": "preserved-annot-value",
 						},
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -915,7 +914,7 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 			assert.Nil(t, err)
 
 			for _, obj := range c.expected {
-				got := &argov1alpha1.Application{}
+				got := &v1alpha1.Application{}
 				_ = client.Get(context.Background(), crtclient.ObjectKey{
 					Namespace: obj.Namespace,
 					Name:      obj.Name,
@@ -932,10 +931,10 @@ func TestCreateOrUpdateInCluster(t *testing.T) {
 func TestRemoveFinalizerOnInvalidDestination_FinalizerTypes(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
@@ -951,7 +950,7 @@ func TestRemoveFinalizerOnInvalidDestination_FinalizerTypes(t *testing.T) {
 		},
 		{
 			name:               "contains only argo finalizer",
-			existingFinalizers: []string{argov1alpha1.ResourcesFinalizerName},
+			existingFinalizers: []string{v1alpha1.ResourcesFinalizerName},
 			expectedFinalizers: nil,
 		},
 		{
@@ -961,36 +960,36 @@ func TestRemoveFinalizerOnInvalidDestination_FinalizerTypes(t *testing.T) {
 		},
 		{
 			name:               "contains both argo and non-argo finalizer",
-			existingFinalizers: []string{"non-argo-finalizer", argov1alpha1.ResourcesFinalizerName},
+			existingFinalizers: []string{"non-argo-finalizer", v1alpha1.ResourcesFinalizerName},
 			expectedFinalizers: []string{"non-argo-finalizer"},
 		},
 	} {
 		t.Run(c.name, func(t *testing.T) {
 
-			appSet := argov1alpha1.ApplicationSet{
+			appSet := v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			}
 
-			app := argov1alpha1.Application{
+			app := v1alpha1.Application{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:       "app1",
 					Finalizers: c.existingFinalizers,
 				},
-				Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSpec{
 					Project: "project",
-					Source:  &argov1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
+					Source:  &v1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
 					// Destination is always invalid, for this test:
-					Destination: argov1alpha1.ApplicationDestination{Name: "my-cluster", Namespace: "namespace"},
+					Destination: v1alpha1.ApplicationDestination{Name: "my-cluster", Namespace: "namespace"},
 				},
 			}
 
@@ -1036,7 +1035,7 @@ func TestRemoveFinalizerOnInvalidDestination_FinalizerTypes(t *testing.T) {
 			err = r.removeFinalizerOnInvalidDestination(context.Background(), appSet, appInputParam, clusterList, appLog)
 			assert.NoError(t, err, "Unexpected error")
 
-			retrievedApp := argov1alpha1.Application{}
+			retrievedApp := v1alpha1.Application{}
 			err = client.Get(context.Background(), crtclient.ObjectKeyFromObject(&app), &retrievedApp)
 			assert.NoError(t, err, "Unexpected error")
 
@@ -1056,28 +1055,28 @@ func TestRemoveFinalizerOnInvalidDestination_FinalizerTypes(t *testing.T) {
 func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
 		// name is human-readable test name
 		name                   string
-		destinationField       argov1alpha1.ApplicationDestination
+		destinationField       v1alpha1.ApplicationDestination
 		expectFinalizerRemoved bool
 	}{
 		{
 			name: "invalid cluster: empty destination",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 			},
 			expectFinalizerRemoved: true,
 		},
 		{
 			name: "invalid cluster: invalid server url",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Server:    "https://1.2.3.4",
 			},
@@ -1085,7 +1084,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 		},
 		{
 			name: "invalid cluster: invalid cluster name",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Name:      "invalid-cluster",
 			},
@@ -1093,7 +1092,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 		},
 		{
 			name: "invalid cluster by both valid",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Name:      "mycluster2",
 				Server:    "https://kubernetes.default.svc",
@@ -1102,7 +1101,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 		},
 		{
 			name: "invalid cluster by both invalid",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Name:      "mycluster3",
 				Server:    "https://4.5.6.7",
@@ -1111,7 +1110,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 		},
 		{
 			name: "valid cluster by name",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Name:      "mycluster2",
 			},
@@ -1119,7 +1118,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 		},
 		{
 			name: "valid cluster by server",
-			destinationField: argov1alpha1.ApplicationDestination{
+			destinationField: v1alpha1.ApplicationDestination{
 				Namespace: "namespace",
 				Server:    "https://kubernetes.default.svc",
 			},
@@ -1129,28 +1128,28 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 
 		t.Run(c.name, func(t *testing.T) {
 
-			appSet := argov1alpha1.ApplicationSet{
+			appSet := v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			}
 
-			app := argov1alpha1.Application{
+			app := v1alpha1.Application{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:       "app1",
-					Finalizers: []string{argov1alpha1.ResourcesFinalizerName},
+					Finalizers: []string{v1alpha1.ResourcesFinalizerName},
 				},
-				Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSpec{
 					Project:     "project",
-					Source:      &argov1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
+					Source:      &v1alpha1.ApplicationSource{Path: "path", TargetRevision: "revision", RepoURL: "repoURL"},
 					Destination: c.destinationField,
 				},
 			}
@@ -1197,7 +1196,7 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 			err = r.removeFinalizerOnInvalidDestination(context.Background(), appSet, appInputParam, clusterList, appLog)
 			assert.NoError(t, err, "Unexpected error")
 
-			retrievedApp := argov1alpha1.Application{}
+			retrievedApp := v1alpha1.Application{}
 			err = client.Get(context.Background(), crtclient.ObjectKeyFromObject(&app), &retrievedApp)
 			assert.NoError(t, err, "Unexpected error")
 
@@ -1215,34 +1214,34 @@ func TestRemoveFinalizerOnInvalidDestination_DestinationTypes(t *testing.T) {
 func TestCreateApplications(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
-		appSet     argov1alpha1.ApplicationSet
-		existsApps []argov1alpha1.Application
-		apps       []argov1alpha1.Application
-		expected   []argov1alpha1.Application
+		appSet     v1alpha1.ApplicationSet
+		existsApps []v1alpha1.Application
+		apps       []v1alpha1.Application
+		expected   []v1alpha1.Application
 	}{
 		{
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
 			},
 			existsApps: nil,
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1257,20 +1256,20 @@ func TestCreateApplications(t *testing.T) {
 			},
 		},
 		{
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existsApps: []argov1alpha1.Application{
+			existsApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1281,22 +1280,22 @@ func TestCreateApplications(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "test",
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1307,27 +1306,27 @@ func TestCreateApplications(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "test",
 					},
 				},
 			},
 		},
 		{
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existsApps: []argov1alpha1.Application{
+			existsApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1338,22 +1337,22 @@ func TestCreateApplications(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "test",
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1364,7 +1363,7 @@ func TestCreateApplications(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -1390,7 +1389,7 @@ func TestCreateApplications(t *testing.T) {
 		assert.Nil(t, err)
 
 		for _, obj := range c.expected {
-			got := &argov1alpha1.Application{}
+			got := &v1alpha1.Application{}
 			_ = client.Get(context.Background(), crtclient.ObjectKey{
 				Namespace: obj.Namespace,
 				Name:      obj.Name,
@@ -1408,38 +1407,38 @@ func TestCreateApplications(t *testing.T) {
 func TestDeleteInCluster(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, c := range []struct {
 		// appSet is the application set on which the delete function is called
-		appSet argov1alpha1.ApplicationSet
+		appSet v1alpha1.ApplicationSet
 		// existingApps is the current state of Applications on the cluster
-		existingApps []argov1alpha1.Application
+		existingApps []v1alpha1.Application
 		// desireApps is the apps generated by the generator that we wish to keep alive
-		desiredApps []argov1alpha1.Application
+		desiredApps []v1alpha1.Application
 		// expected is the list of applications that we expect to exist after calling delete
-		expected []argov1alpha1.Application
+		expected []v1alpha1.Application
 		// notExpected is the list of applications that we expect not to exist after calling delete
-		notExpected []argov1alpha1.Application
+		notExpected []v1alpha1.Application
 	}{
 		{
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "namespace",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Template: argov1alpha1.ApplicationSetTemplate{
-						Spec: argov1alpha1.ApplicationSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Template: v1alpha1.ApplicationSetTemplate{
+						Spec: v1alpha1.ApplicationSpec{
 							Project: "project",
 						},
 					},
 				},
 			},
-			existingApps: []argov1alpha1.Application{
+			existingApps: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1450,7 +1449,7 @@ func TestDeleteInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -1464,22 +1463,22 @@ func TestDeleteInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			desiredApps: []argov1alpha1.Application{
+			desiredApps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "keep",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			expected: []argov1alpha1.Application{
+			expected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1490,12 +1489,12 @@ func TestDeleteInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "2",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
 			},
-			notExpected: []argov1alpha1.Application{
+			notExpected: []v1alpha1.Application{
 				{
 					TypeMeta: metav1.TypeMeta{
 						Kind:       "Application",
@@ -1506,7 +1505,7 @@ func TestDeleteInCluster(t *testing.T) {
 						Namespace:       "namespace",
 						ResourceVersion: "1",
 					},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "project",
 					},
 				},
@@ -1535,7 +1534,7 @@ func TestDeleteInCluster(t *testing.T) {
 
 		// For each of the expected objects, verify they exist on the cluster
 		for _, obj := range c.expected {
-			got := &argov1alpha1.Application{}
+			got := &v1alpha1.Application{}
 			_ = client.Get(context.Background(), crtclient.ObjectKey{
 				Namespace: obj.Namespace,
 				Name:      obj.Name,
@@ -1549,7 +1548,7 @@ func TestDeleteInCluster(t *testing.T) {
 
 		// Verify each of the unexpected objs cannot be found
 		for _, obj := range c.notExpected {
-			got := &argov1alpha1.Application{}
+			got := &v1alpha1.Application{}
 			err := client.Get(context.Background(), crtclient.ObjectKey{
 				Namespace: obj.Namespace,
 				Name:      obj.Name,
@@ -1562,17 +1561,17 @@ func TestDeleteInCluster(t *testing.T) {
 
 func TestGetMinRequeueAfter(t *testing.T) {
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	client := fake.NewClientBuilder().WithScheme(scheme).Build()
 
-	generator := argov1alpha1.ApplicationSetGenerator{
-		List:     &argov1alpha1.ListGenerator{},
-		Git:      &argov1alpha1.GitGenerator{},
-		Clusters: &argov1alpha1.ClusterGenerator{},
+	generator := v1alpha1.ApplicationSetGenerator{
+		List:     &v1alpha1.ListGenerator{},
+		Git:      &v1alpha1.GitGenerator{},
+		Clusters: &v1alpha1.ClusterGenerator{},
 	}
 
 	generatorMock0 := generatorMock{}
@@ -1598,9 +1597,9 @@ func TestGetMinRequeueAfter(t *testing.T) {
 		},
 	}
 
-	got := r.getMinRequeueAfter(&argov1alpha1.ApplicationSet{
-		Spec: argov1alpha1.ApplicationSetSpec{
-			Generators: []argov1alpha1.ApplicationSetGenerator{generator},
+	got := r.getMinRequeueAfter(&v1alpha1.ApplicationSet{
+		Spec: v1alpha1.ApplicationSetSpec{
+			Generators: []v1alpha1.ApplicationSetGenerator{generator},
 		},
 	})
 
@@ -1610,26 +1609,26 @@ func TestGetMinRequeueAfter(t *testing.T) {
 func TestValidateGeneratedApplications(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	client := fake.NewClientBuilder().WithScheme(scheme).Build()
 
 	// Valid cluster
-	myCluster := argov1alpha1.Cluster{
+	myCluster := v1alpha1.Cluster{
 		Server: "https://kubernetes.default.svc",
 		Name:   "my-cluster",
 	}
 
 	// Valid project
-	myProject := &argov1alpha1.AppProject{
+	myProject := &v1alpha1.AppProject{
 		ObjectMeta: metav1.ObjectMeta{Name: "default", Namespace: "namespace"},
-		Spec: argov1alpha1.AppProjectSpec{
+		Spec: v1alpha1.AppProjectSpec{
 			SourceRepos: []string{"*"},
-			Destinations: []argov1alpha1.ApplicationDestination{
+			Destinations: []v1alpha1.ApplicationDestination{
 				{
 					Namespace: "*",
 					Server:    "*",
@@ -1647,24 +1646,24 @@ func TestValidateGeneratedApplications(t *testing.T) {
 	// Test a subset of the validations that 'validateGeneratedApplications' performs
 	for _, cc := range []struct {
 		name             string
-		apps             []argov1alpha1.Application
+		apps             []v1alpha1.Application
 		expectedErrors   []string
 		validationErrors map[int]error
 	}{
 		{
 			name: "valid app should return true",
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					TypeMeta:   metav1.TypeMeta{},
 					ObjectMeta: metav1.ObjectMeta{},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "default",
-						Source: &argov1alpha1.ApplicationSource{
+						Source: &v1alpha1.ApplicationSource{
 							RepoURL:        "https://url",
 							Path:           "/",
 							TargetRevision: "HEAD",
 						},
-						Destination: argov1alpha1.ApplicationDestination{
+						Destination: v1alpha1.ApplicationDestination{
 							Namespace: "namespace",
 							Name:      "my-cluster",
 						},
@@ -1676,18 +1675,18 @@ func TestValidateGeneratedApplications(t *testing.T) {
 		},
 		{
 			name: "can't have both name and server defined",
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					TypeMeta:   metav1.TypeMeta{},
 					ObjectMeta: metav1.ObjectMeta{},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "default",
-						Source: &argov1alpha1.ApplicationSource{
+						Source: &v1alpha1.ApplicationSource{
 							RepoURL:        "https://url",
 							Path:           "/",
 							TargetRevision: "HEAD",
 						},
-						Destination: argov1alpha1.ApplicationDestination{
+						Destination: v1alpha1.ApplicationDestination{
 							Namespace: "namespace",
 							Server:    "my-server",
 							Name:      "my-cluster",
@@ -1700,18 +1699,18 @@ func TestValidateGeneratedApplications(t *testing.T) {
 		},
 		{
 			name: "project mismatch should return error",
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					TypeMeta:   metav1.TypeMeta{},
 					ObjectMeta: metav1.ObjectMeta{},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "DOES-NOT-EXIST",
-						Source: &argov1alpha1.ApplicationSource{
+						Source: &v1alpha1.ApplicationSource{
 							RepoURL:        "https://url",
 							Path:           "/",
 							TargetRevision: "HEAD",
 						},
-						Destination: argov1alpha1.ApplicationDestination{
+						Destination: v1alpha1.ApplicationDestination{
 							Namespace: "namespace",
 							Name:      "my-cluster",
 						},
@@ -1723,18 +1722,18 @@ func TestValidateGeneratedApplications(t *testing.T) {
 		},
 		{
 			name: "valid app should return true",
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					TypeMeta:   metav1.TypeMeta{},
 					ObjectMeta: metav1.ObjectMeta{},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "default",
-						Source: &argov1alpha1.ApplicationSource{
+						Source: &v1alpha1.ApplicationSource{
 							RepoURL:        "https://url",
 							Path:           "/",
 							TargetRevision: "HEAD",
 						},
-						Destination: argov1alpha1.ApplicationDestination{
+						Destination: v1alpha1.ApplicationDestination{
 							Namespace: "namespace",
 							Name:      "my-cluster",
 						},
@@ -1746,18 +1745,18 @@ func TestValidateGeneratedApplications(t *testing.T) {
 		},
 		{
 			name: "cluster should match",
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					TypeMeta:   metav1.TypeMeta{},
 					ObjectMeta: metav1.ObjectMeta{},
-					Spec: argov1alpha1.ApplicationSpec{
+					Spec: v1alpha1.ApplicationSpec{
 						Project: "default",
-						Source: &argov1alpha1.ApplicationSource{
+						Source: &v1alpha1.ApplicationSource{
 							RepoURL:        "https://url",
 							Path:           "/",
 							TargetRevision: "HEAD",
 						},
-						Destination: argov1alpha1.ApplicationDestination{
+						Destination: v1alpha1.ApplicationDestination{
 							Namespace: "namespace",
 							Name:      "nonexistent-cluster",
 						},
@@ -1791,7 +1790,7 @@ func TestValidateGeneratedApplications(t *testing.T) {
 
 			argoDBMock := dbmocks.ArgoDB{}
 			argoDBMock.On("GetCluster", mock.Anything, "https://kubernetes.default.svc").Return(&myCluster, nil)
-			argoDBMock.On("ListClusters", mock.Anything).Return(&argov1alpha1.ClusterList{Items: []argov1alpha1.Cluster{
+			argoDBMock.On("ListClusters", mock.Anything).Return(&v1alpha1.ClusterList{Items: []v1alpha1.Cluster{
 				myCluster,
 			}}, nil)
 
@@ -1810,7 +1809,7 @@ func TestValidateGeneratedApplications(t *testing.T) {
 				KubeClientset:    kubeclientset,
 			}
 
-			appSetInfo := argov1alpha1.ApplicationSet{}
+			appSetInfo := v1alpha1.ApplicationSet{}
 
 			validationErrors, _ := r.validateGeneratedApplications(context.TODO(), cc.apps, appSetInfo, "namespace")
 			var errorMessages []string
@@ -1848,25 +1847,25 @@ func TestValidateGeneratedApplications(t *testing.T) {
 func TestReconcilerValidationErrorBehaviour(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	defaultProject := argov1alpha1.AppProject{
+	defaultProject := v1alpha1.AppProject{
 		ObjectMeta: metav1.ObjectMeta{Name: "default", Namespace: "argocd"},
-		Spec:       argov1alpha1.AppProjectSpec{SourceRepos: []string{"*"}, Destinations: []argov1alpha1.ApplicationDestination{{Namespace: "*", Server: "https://good-cluster"}}},
+		Spec:       v1alpha1.AppProjectSpec{SourceRepos: []string{"*"}, Destinations: []v1alpha1.ApplicationDestination{{Namespace: "*", Server: "https://good-cluster"}}},
 	}
-	appSet := argov1alpha1.ApplicationSet{
+	appSet := v1alpha1.ApplicationSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "name",
 			Namespace: "argocd",
 		},
-		Spec: argov1alpha1.ApplicationSetSpec{
+		Spec: v1alpha1.ApplicationSetSpec{
 			GoTemplate: true,
-			Generators: []argov1alpha1.ApplicationSetGenerator{
+			Generators: []v1alpha1.ApplicationSetGenerator{
 				{
-					List: &argov1alpha1.ListGenerator{
+					List: &v1alpha1.ListGenerator{
 						Elements: []apiextensionsv1.JSON{{
 							Raw: []byte(`{"cluster": "good-cluster","url": "https://good-cluster"}`),
 						}, {
@@ -1875,15 +1874,15 @@ func TestReconcilerValidationErrorBehaviour(t *testing.T) {
 					},
 				},
 			},
-			Template: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			Template: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name:      "{{.cluster}}",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSpec{
-					Source:      &argov1alpha1.ApplicationSource{RepoURL: "https://github.com/argoproj/argocd-example-apps", Path: "guestbook"},
+				Spec: v1alpha1.ApplicationSpec{
+					Source:      &v1alpha1.ApplicationSource{RepoURL: "https://github.com/argoproj/argocd-example-apps", Path: "guestbook"},
 					Project:     "default",
-					Destination: argov1alpha1.ApplicationDestination{Server: "{{.url}}"},
+					Destination: v1alpha1.ApplicationDestination{Server: "{{.url}}"},
 				},
 			},
 		},
@@ -1894,11 +1893,11 @@ func TestReconcilerValidationErrorBehaviour(t *testing.T) {
 	argoObjs := []runtime.Object{&defaultProject}
 
 	client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&appSet).Build()
-	goodCluster := argov1alpha1.Cluster{Server: "https://good-cluster", Name: "good-cluster"}
-	badCluster := argov1alpha1.Cluster{Server: "https://bad-cluster", Name: "bad-cluster"}
+	goodCluster := v1alpha1.Cluster{Server: "https://good-cluster", Name: "good-cluster"}
+	badCluster := v1alpha1.Cluster{Server: "https://bad-cluster", Name: "bad-cluster"}
 	argoDBMock.On("GetCluster", mock.Anything, "https://good-cluster").Return(&goodCluster, nil)
 	argoDBMock.On("GetCluster", mock.Anything, "https://bad-cluster").Return(&badCluster, nil)
-	argoDBMock.On("ListClusters", mock.Anything).Return(&argov1alpha1.ClusterList{Items: []argov1alpha1.Cluster{
+	argoDBMock.On("ListClusters", mock.Anything).Return(&v1alpha1.ClusterList{Items: []v1alpha1.Cluster{
 		goodCluster,
 	}}, nil)
 
@@ -1928,7 +1927,7 @@ func TestReconcilerValidationErrorBehaviour(t *testing.T) {
 	assert.Nil(t, err)
 	assert.True(t, res.RequeueAfter == 0)
 
-	var app argov1alpha1.Application
+	var app v1alpha1.Application
 
 	// make sure good app got created
 	err = r.Client.Get(context.TODO(), crtclient.ObjectKey{Namespace: "argocd", Name: "good-cluster"}, &app)
@@ -1942,33 +1941,33 @@ func TestReconcilerValidationErrorBehaviour(t *testing.T) {
 
 func TestSetApplicationSetStatusCondition(t *testing.T) {
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	appSet := argov1alpha1.ApplicationSet{
+	appSet := v1alpha1.ApplicationSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "name",
 			Namespace: "argocd",
 		},
-		Spec: argov1alpha1.ApplicationSetSpec{
-			Generators: []argov1alpha1.ApplicationSetGenerator{
-				{List: &argov1alpha1.ListGenerator{
+		Spec: v1alpha1.ApplicationSetSpec{
+			Generators: []v1alpha1.ApplicationSetGenerator{
+				{List: &v1alpha1.ListGenerator{
 					Elements: []apiextensionsv1.JSON{{
 						Raw: []byte(`{"cluster": "my-cluster","url": "https://kubernetes.default.svc"}`),
 					}},
 				}},
 			},
-			Template: argov1alpha1.ApplicationSetTemplate{},
+			Template: v1alpha1.ApplicationSetTemplate{},
 		},
 	}
 
-	appCondition := argov1alpha1.ApplicationSetCondition{
-		Type:    argov1alpha1.ApplicationSetConditionResourcesUpToDate,
+	appCondition := v1alpha1.ApplicationSetCondition{
+		Type:    v1alpha1.ApplicationSetConditionResourcesUpToDate,
 		Message: "All applications have been generated successfully",
-		Reason:  argov1alpha1.ApplicationSetReasonApplicationSetUpToDate,
-		Status:  argov1alpha1.ApplicationSetConditionStatusTrue,
+		Reason:  v1alpha1.ApplicationSetReasonApplicationSetUpToDate,
+		Status:  v1alpha1.ApplicationSetConditionStatusTrue,
 	}
 
 	kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...)
@@ -2004,8 +2003,8 @@ func TestGenerateAppsUsingPullRequestGenerator(t *testing.T) {
 	for _, cases := range []struct {
 		name        string
 		params      []map[string]interface{}
-		template    argov1alpha1.ApplicationSetTemplate
-		expectedApp []argov1alpha1.Application
+		template    v1alpha1.ApplicationSetTemplate
+		expectedApp []v1alpha1.Application
 	}{
 		{
 			name: "Generate an application from a go template application set manifest using a pull request generator",
@@ -2016,25 +2015,25 @@ func TestGenerateAppsUsingPullRequestGenerator(t *testing.T) {
 				"head_sha":       "089d92cbf9ff857a39e6feccd32798ca700fb958",
 				"head_short_sha": "089d92cb",
 				"labels":         []string{"label1"}}},
-			template: argov1alpha1.ApplicationSetTemplate{
-				ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+			template: v1alpha1.ApplicationSetTemplate{
+				ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 					Name: "AppSet-{{.branch}}-{{.number}}",
 					Labels: map[string]string{
 						"app1": "{{index .labels 0}}",
 					},
 				},
-				Spec: argov1alpha1.ApplicationSpec{
-					Source: &argov1alpha1.ApplicationSource{
+				Spec: v1alpha1.ApplicationSpec{
+					Source: &v1alpha1.ApplicationSource{
 						RepoURL:        "https://testurl/testRepo",
 						TargetRevision: "{{.head_short_sha}}",
 					},
-					Destination: argov1alpha1.ApplicationDestination{
+					Destination: v1alpha1.ApplicationDestination{
 						Server:    "https://kubernetes.default.svc",
 						Namespace: "AppSet-{{.branch_slug}}-{{.head_sha}}",
 					},
 				},
 			},
-			expectedApp: []argov1alpha1.Application{
+			expectedApp: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "AppSet-branch1-1",
@@ -2060,8 +2059,8 @@ func TestGenerateAppsUsingPullRequestGenerator(t *testing.T) {
 		t.Run(cases.name, func(t *testing.T) {
 
 			generatorMock := generatorMock{}
-			generator := argov1alpha1.ApplicationSetGenerator{
-				PullRequest: &argov1alpha1.PullRequestGenerator{},
+			generator := v1alpha1.ApplicationSetGenerator{
+				PullRequest: &v1alpha1.PullRequestGenerator{},
 			}
 
 			generatorMock.On("GenerateParams", &generator).
@@ -2081,11 +2080,11 @@ func TestGenerateAppsUsingPullRequestGenerator(t *testing.T) {
 				KubeClientset: kubefake.NewSimpleClientset(),
 			}
 
-			gotApp, _, _ := appSetReconciler.generateApplications(argov1alpha1.ApplicationSet{
-				Spec: argov1alpha1.ApplicationSetSpec{
+			gotApp, _, _ := appSetReconciler.generateApplications(v1alpha1.ApplicationSet{
+				Spec: v1alpha1.ApplicationSetSpec{
 					GoTemplate: true,
-					Generators: []argov1alpha1.ApplicationSetGenerator{{
-						PullRequest: &argov1alpha1.PullRequestGenerator{},
+					Generators: []v1alpha1.ApplicationSetGenerator{{
+						PullRequest: &v1alpha1.PullRequestGenerator{},
 					}},
 					Template: cases.template,
 				},
@@ -2101,17 +2100,17 @@ func TestGenerateAppsUsingPullRequestGenerator(t *testing.T) {
 
 func TestPolicies(t *testing.T) {
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	defaultProject := argov1alpha1.AppProject{
+	defaultProject := v1alpha1.AppProject{
 		ObjectMeta: metav1.ObjectMeta{Name: "default", Namespace: "argocd"},
-		Spec:       argov1alpha1.AppProjectSpec{SourceRepos: []string{"*"}, Destinations: []argov1alpha1.ApplicationDestination{{Namespace: "*", Server: "https://kubernetes.default.svc"}}},
+		Spec:       v1alpha1.AppProjectSpec{SourceRepos: []string{"*"}, Destinations: []v1alpha1.ApplicationDestination{{Namespace: "*", Server: "https://kubernetes.default.svc"}}},
 	}
-	myCluster := argov1alpha1.Cluster{
+	myCluster := v1alpha1.Cluster{
 		Server: "https://kubernetes.default.svc",
 		Name:   "my-cluster",
 	}
@@ -2156,16 +2155,16 @@ func TestPolicies(t *testing.T) {
 			policy := utils.Policies[c.policyName]
 			assert.NotNil(t, policy)
 
-			appSet := argov1alpha1.ApplicationSet{
+			appSet := v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
+				Spec: v1alpha1.ApplicationSetSpec{
 					GoTemplate: true,
-					Generators: []argov1alpha1.ApplicationSetGenerator{
+					Generators: []v1alpha1.ApplicationSetGenerator{
 						{
-							List: &argov1alpha1.ListGenerator{
+							List: &v1alpha1.ListGenerator{
 								Elements: []apiextensionsv1.JSON{
 									{
 										Raw: []byte(`{"name": "my-app"}`),
@@ -2174,18 +2173,18 @@ func TestPolicies(t *testing.T) {
 							},
 						},
 					},
-					Template: argov1alpha1.ApplicationSetTemplate{
-						ApplicationSetTemplateMeta: argov1alpha1.ApplicationSetTemplateMeta{
+					Template: v1alpha1.ApplicationSetTemplate{
+						ApplicationSetTemplateMeta: v1alpha1.ApplicationSetTemplateMeta{
 							Name:      "{{.name}}",
 							Namespace: "argocd",
 							Annotations: map[string]string{
 								"key": "value",
 							},
 						},
-						Spec: argov1alpha1.ApplicationSpec{
-							Source:      &argov1alpha1.ApplicationSource{RepoURL: "https://github.com/argoproj/argocd-example-apps", Path: "guestbook"},
+						Spec: v1alpha1.ApplicationSpec{
+							Source:      &v1alpha1.ApplicationSource{RepoURL: "https://github.com/argoproj/argocd-example-apps", Path: "guestbook"},
 							Project:     "default",
-							Destination: argov1alpha1.ApplicationDestination{Server: "https://kubernetes.default.svc"},
+							Destination: v1alpha1.ApplicationDestination{Server: "https://kubernetes.default.svc"},
 						},
 					},
 				},
@@ -2219,7 +2218,7 @@ func TestPolicies(t *testing.T) {
 			assert.Nil(t, err)
 			assert.True(t, res.RequeueAfter == 0)
 
-			var app argov1alpha1.Application
+			var app v1alpha1.Application
 			err = r.Client.Get(context.TODO(), crtclient.ObjectKey{Namespace: "argocd", Name: "my-app"}, &app)
 			assert.NoError(t, err)
 			assert.Equal(t, app.Annotations["key"], "value")
@@ -2245,8 +2244,8 @@ func TestPolicies(t *testing.T) {
 			// Check if Application is deleted
 			err = r.Client.Get(context.TODO(), crtclient.ObjectKey{Namespace: "argocd", Name: "name"}, &appSet)
 			assert.NoError(t, err)
-			appSet.Spec.Generators[0] = argov1alpha1.ApplicationSetGenerator{
-				List: &argov1alpha1.ListGenerator{
+			appSet.Spec.Generators[0] = v1alpha1.ApplicationSetGenerator{
+				List: &v1alpha1.ListGenerator{
 					Elements: []apiextensionsv1.JSON{},
 				},
 			}
@@ -2270,29 +2269,29 @@ func TestPolicies(t *testing.T) {
 
 func TestSetApplicationSetApplicationStatus(t *testing.T) {
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	appSet := argov1alpha1.ApplicationSet{
+	appSet := v1alpha1.ApplicationSet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "name",
 			Namespace: "argocd",
 		},
-		Spec: argov1alpha1.ApplicationSetSpec{
-			Generators: []argov1alpha1.ApplicationSetGenerator{
-				{List: &argov1alpha1.ListGenerator{
+		Spec: v1alpha1.ApplicationSetSpec{
+			Generators: []v1alpha1.ApplicationSetGenerator{
+				{List: &v1alpha1.ListGenerator{
 					Elements: []apiextensionsv1.JSON{{
 						Raw: []byte(`{"cluster": "my-cluster","url": "https://kubernetes.default.svc"}`),
 					}},
 				}},
 			},
-			Template: argov1alpha1.ApplicationSetTemplate{},
+			Template: v1alpha1.ApplicationSetTemplate{},
 		},
 	}
 
-	appStatuses := []argov1alpha1.ApplicationSetApplicationStatus{
+	appStatuses := []v1alpha1.ApplicationSetApplicationStatus{
 		{
 			Application:        "my-application",
 			LastTransitionTime: &metav1.Time{},
@@ -2329,65 +2328,65 @@ func TestSetApplicationSetApplicationStatus(t *testing.T) {
 func TestBuildAppDependencyList(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	client := fake.NewClientBuilder().WithScheme(scheme).Build()
 
 	for _, cc := range []struct {
 		name            string
-		appSet          argov1alpha1.ApplicationSet
-		apps            []argov1alpha1.Application
+		appSet          v1alpha1.ApplicationSet
+		apps            []v1alpha1.Application
 		expectedList    [][]string
 		expectedStepMap map[string]int
 	}{
 		{
 			name: "handles an empty set of applications and no strategy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{},
+				Spec: v1alpha1.ApplicationSetSpec{},
 			},
-			apps:            []argov1alpha1.Application{},
+			apps:            []v1alpha1.Application{},
 			expectedList:    [][]string{},
 			expectedStepMap: map[string]int{},
 		},
 		{
 			name: "handles an empty set of applications and ignores AllAtOnce strategy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "AllAtOnce",
 					},
 				},
 			},
-			apps:            []argov1alpha1.Application{},
+			apps:            []v1alpha1.Application{},
 			expectedList:    [][]string{},
 			expectedStepMap: map[string]int{},
 		},
 		{
 			name: "handles an empty set of applications with good 'In' selectors",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2402,7 +2401,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{},
+			apps: []v1alpha1.Application{},
 			expectedList: [][]string{
 				{},
 			},
@@ -2410,18 +2409,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "handles selecting 1 application with 1 'In' selector",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2436,7 +2435,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-dev",
@@ -2455,18 +2454,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "handles 'In' selectors that select no applications",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2477,7 +2476,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2488,7 +2487,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2503,7 +2502,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-qa",
@@ -2533,18 +2532,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "multiple 'In' selectors in the same matchExpression only select Applications that match all selectors",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "region",
 											Operator: "In",
@@ -2566,7 +2565,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-qa1",
@@ -2594,18 +2593,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "multiple values in the same 'In' matchExpression can match on any value",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2621,7 +2620,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-dev",
@@ -2658,18 +2657,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "handles an empty set of applications with good 'NotIn' selectors",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2684,7 +2683,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{},
+			apps: []v1alpha1.Application{},
 			expectedList: [][]string{
 				{},
 			},
@@ -2692,18 +2691,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "selects 1 application with 1 'NotIn' selector",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "NotIn",
@@ -2718,7 +2717,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-dev",
@@ -2737,18 +2736,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "'NotIn' selectors that select no applications",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "NotIn",
@@ -2763,7 +2762,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-qa",
@@ -2791,18 +2790,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "multiple 'NotIn' selectors only match Applications with all labels",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "region",
 											Operator: "NotIn",
@@ -2824,7 +2823,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-qa1",
@@ -2852,18 +2851,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "multiple values in the same 'NotIn' matchExpression exclude a match from any value",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "NotIn",
@@ -2879,7 +2878,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-dev",
@@ -2915,18 +2914,18 @@ func TestBuildAppDependencyList(t *testing.T) {
 		},
 		{
 			name: "in a mix of 'In' and 'NotIn' selectors, 'NotIn' takes precedence",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{
 										{
 											Key:      "env",
 											Operator: "In",
@@ -2949,7 +2948,7 @@ func TestBuildAppDependencyList(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app-dev",
@@ -3013,32 +3012,32 @@ func TestBuildAppDependencyList(t *testing.T) {
 func TestBuildAppSyncMap(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	client := fake.NewClientBuilder().WithScheme(scheme).Build()
 
 	for _, cc := range []struct {
 		name              string
-		appSet            argov1alpha1.ApplicationSet
-		appMap            map[string]argov1alpha1.Application
+		appSet            v1alpha1.ApplicationSet
+		appMap            map[string]v1alpha1.Application
 		appDependencyList [][]string
 		expectedMap       map[string]bool
 	}{
 		{
 			name: "handles an empty app dependency list",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
@@ -3047,15 +3046,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles two applications with no statuses",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
@@ -3070,15 +3069,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles applications after an empty selection",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
@@ -3093,19 +3092,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles RollingSync applications that are healthy and have no changes",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Healthy",
@@ -3117,20 +3116,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 					},
 				},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3138,15 +3137,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3162,19 +3161,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "blocks RollingSync applications that are healthy and have no changes, but are still pending",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Pending",
@@ -3186,20 +3185,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 					},
 				},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3207,15 +3206,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3231,19 +3230,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles RollingSync applications that are up to date and healthy, but still syncing",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Progressing",
@@ -3255,20 +3254,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 					},
 				},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationRunning,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3276,15 +3275,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationRunning,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3300,19 +3299,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles RollingSync applications that are up to date and synced, but degraded",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Progressing",
@@ -3324,20 +3323,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 					},
 				},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusDegraded,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationRunning,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3345,15 +3344,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusDegraded,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationRunning,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3369,19 +3368,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles RollingSync applications that are OutOfSync and healthy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Healthy",
@@ -3397,20 +3396,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 				{"app1"},
 				{"app2"},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -3418,15 +3417,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -3438,19 +3437,19 @@ func TestBuildAppSyncMap(t *testing.T) {
 		},
 		{
 			name: "handles a lot of applications",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Status:      "Healthy",
@@ -3478,20 +3477,20 @@ func TestBuildAppSyncMap(t *testing.T) {
 					},
 				},
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3499,15 +3498,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3515,15 +3514,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app3",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3531,15 +3530,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app5",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3547,15 +3546,15 @@ func TestBuildAppSyncMap(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app6",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusDegraded,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
@@ -3605,69 +3604,69 @@ func TestBuildAppSyncMap(t *testing.T) {
 func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, cc := range []struct {
 		name              string
-		appSet            argov1alpha1.ApplicationSet
-		apps              []argov1alpha1.Application
+		appSet            v1alpha1.ApplicationSet
+		apps              []v1alpha1.Application
 		appStepMap        map[string]int
-		expectedAppStatus []argov1alpha1.ApplicationSetApplicationStatus
+		expectedAppStatus []v1alpha1.ApplicationSetApplicationStatus
 	}{
 		{
 			name: "handles a nil list of statuses and no applications",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
-			apps:              []argov1alpha1.Application{},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+			apps:              []v1alpha1.Application{},
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 		},
 		{
 			name: "handles a nil list of statuses with a healthy application",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource is already Healthy, updating status from Waiting to Healthy.",
@@ -3678,38 +3677,38 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "handles an empty list of statuses with a healthy application",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{},
+				Status: v1alpha1.ApplicationSetStatus{},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource is already Healthy, updating status from Waiting to Healthy.",
@@ -3720,19 +3719,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses an OutOfSync RollingSync application to waiting",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "",
@@ -3742,19 +3741,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+					Status: v1alpha1.ApplicationStatus{
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application has pending changes, setting status to Waiting.",
@@ -3765,19 +3764,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a pending progressing application to progressing",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "",
@@ -3787,19 +3786,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusProgressing,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource became Progressing, updating status from Pending to Progressing.",
@@ -3810,19 +3809,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a pending syncing application to progressing",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "",
@@ -3832,25 +3831,25 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationRunning,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource became Progressing, updating status from Pending to Progressing.",
@@ -3861,19 +3860,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a progressing application to healthy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "",
@@ -3883,25 +3882,25 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource became Healthy, updating status from Progressing to Healthy.",
@@ -3912,19 +3911,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a waiting healthy application to healthy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "",
@@ -3934,25 +3933,25 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource is already Healthy, updating status from Waiting to Healthy.",
@@ -3963,32 +3962,32 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a new outofsync application in a later step to waiting",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusHealthy,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -3997,7 +3996,7 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 				"app1": 1,
 				"app2": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "No Application status found, defaulting status to Waiting.",
@@ -4008,19 +4007,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "progresses a pending application with a successful sync to progressing",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							LastTransitionTime: &metav1.Time{
@@ -4033,28 +4032,28 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusDegraded,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 							StartedAt: metav1.Time{
 								Time: time.Now(),
 							},
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application resource completed a sync successfully, updating status from Pending to Progressing.",
@@ -4065,19 +4064,19 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 		},
 		{
 			name: "does not progresses a pending application with an old successful sync to progressing",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type:        "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{},
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							LastTransitionTime: &metav1.Time{
@@ -4090,28 +4089,28 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 					},
 				},
 			},
-			apps: []argov1alpha1.Application{
+			apps: []v1alpha1.Application{
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Health: argov1alpha1.HealthStatus{
+					Status: v1alpha1.ApplicationStatus{
+						Health: v1alpha1.HealthStatus{
 							Status: health.HealthStatusDegraded,
 						},
-						OperationState: &argov1alpha1.OperationState{
+						OperationState: &v1alpha1.OperationState{
 							Phase: common.OperationSucceeded,
 							StartedAt: metav1.Time{
 								Time: time.Now().Add(time.Duration(-2) * time.Minute),
 							},
 						},
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeSynced,
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeSynced,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application: "app1",
 					Message:     "Application moved to Pending status, watching for the Application resource to start Progressing.",
@@ -4156,93 +4155,93 @@ func TestUpdateApplicationSetApplicationStatus(t *testing.T) {
 func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 
 	scheme := runtime.NewScheme()
-	err := argov1alpha1.AddToScheme(scheme)
+	err := v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
-	err = argov1alpha1.AddToScheme(scheme)
+	err = v1alpha1.AddToScheme(scheme)
 	assert.Nil(t, err)
 
 	for _, cc := range []struct {
 		name              string
-		appSet            argov1alpha1.ApplicationSet
+		appSet            v1alpha1.ApplicationSet
 		appSyncMap        map[string]bool
 		appStepMap        map[string]int
-		appMap            map[string]argov1alpha1.Application
-		expectedAppStatus []argov1alpha1.ApplicationSetApplicationStatus
+		appMap            map[string]v1alpha1.Application
+		expectedAppStatus []v1alpha1.ApplicationSetApplicationStatus
 	}{
 		{
 			name: "handles an empty appSync and appStepMap",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 				},
 			},
 			appSyncMap:        map[string]bool{},
 			appStepMap:        map[string]int{},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 		},
 		{
 			name: "handles an empty strategy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+				Spec: v1alpha1.ApplicationSetSpec{},
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 				},
 			},
 			appSyncMap:        map[string]bool{},
 			appStepMap:        map[string]int{},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 		},
 		{
 			name: "handles an empty applicationset strategy",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{},
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 				},
 			},
 			appSyncMap:        map[string]bool{},
 			appStepMap:        map[string]int{},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 		},
 		{
 			name: "handles an appSyncMap with no existing statuses",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 				},
 			},
 			appSyncMap: map[string]bool{
@@ -4253,32 +4252,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app1": 0,
 				"app2": 1,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{},
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{},
 		},
 		{
 			name: "handles updating a RollingSync status from Waiting to Pending",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4293,7 +4292,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 			appStepMap: map[string]int{
 				"app1": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4305,28 +4304,28 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "does not update a RollingSync status if appSyncMap is false",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4342,7 +4341,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 			appStepMap: map[string]int{
 				"app1": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4354,28 +4353,28 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "does not update a status if status is not pending",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.",
@@ -4391,7 +4390,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 			appStepMap: map[string]int{
 				"app1": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4403,32 +4402,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "does not update a status if maxUpdate has already been reached with RollingSync",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 									MaxUpdate: &intstr.IntOrString{
 										Type:   intstr.Int,
 										IntVal: 3,
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application resource became Progressing, updating status from Pending to Progressing.",
@@ -4468,14 +4467,14 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app3": 0,
 				"app4": 0,
 			},
-			appMap: map[string]argov1alpha1.Application{
+			appMap: map[string]v1alpha1.Application{
 				"app1": {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app1",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+					Status: v1alpha1.ApplicationStatus{
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -4483,9 +4482,9 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app2",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+					Status: v1alpha1.ApplicationStatus{
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -4493,9 +4492,9 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app3",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+					Status: v1alpha1.ApplicationStatus{
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
@@ -4503,14 +4502,14 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "app4",
 					},
-					Status: argov1alpha1.ApplicationStatus{
-						Sync: argov1alpha1.SyncStatus{
-							Status: argov1alpha1.SyncStatusCodeOutOfSync,
+					Status: v1alpha1.ApplicationStatus{
+						Sync: v1alpha1.SyncStatus{
+							Status: v1alpha1.SyncStatusCodeOutOfSync,
 						},
 					},
 				},
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4543,32 +4542,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "rounds down for maxUpdate set to percentage string",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 									MaxUpdate: &intstr.IntOrString{
 										Type:   intstr.String,
 										StrVal: "50%",
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4600,7 +4599,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app2": 0,
 				"app3": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4626,32 +4625,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "does not update any applications with maxUpdate set to 0",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 									MaxUpdate: &intstr.IntOrString{
 										Type:   intstr.Int,
 										IntVal: 0,
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4683,7 +4682,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app2": 0,
 				"app3": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4709,32 +4708,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "updates all applications with maxUpdate set to 100%",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 									MaxUpdate: &intstr.IntOrString{
 										Type:   intstr.String,
 										StrVal: "100%",
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4766,7 +4765,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app2": 0,
 				"app3": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
@@ -4792,32 +4791,32 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 		},
 		{
 			name: "updates at least 1 application with maxUpdate >0%",
-			appSet: argov1alpha1.ApplicationSet{
+			appSet: v1alpha1.ApplicationSet{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "name",
 					Namespace: "argocd",
 				},
-				Spec: argov1alpha1.ApplicationSetSpec{
-					Strategy: &argov1alpha1.ApplicationSetStrategy{
+				Spec: v1alpha1.ApplicationSetSpec{
+					Strategy: &v1alpha1.ApplicationSetStrategy{
 						Type: "RollingSync",
-						RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{
-							Steps: []argov1alpha1.ApplicationSetRolloutStep{
+						RollingSync: &v1alpha1.ApplicationSetRolloutStrategy{
+							Steps: []v1alpha1.ApplicationSetRolloutStep{
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 									MaxUpdate: &intstr.IntOrString{
 										Type:   intstr.String,
 										StrVal: "1%",
 									},
 								},
 								{
-									MatchExpressions: []argov1alpha1.ApplicationMatchExpression{},
+									MatchExpressions: []v1alpha1.ApplicationMatchExpression{},
 								},
 							},
 						},
 					},
 				},
-				Status: argov1alpha1.ApplicationSetStatus{
-					ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+				Status: v1alpha1.ApplicationSetStatus{
+					ApplicationStatus: []v1alpha1.ApplicationSetApplicationStatus{
 						{
 							Application: "app1",
 							Message:     "Application is out of date with the current AppSet generation, setting status to Waiting.",
@@ -4849,7 +4848,7 @@ func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) {
 				"app2": 0,
 				"app3": 0,
 			},
-			expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{
+			expectedAppStatus: []v1alpha1.ApplicationSetApplicationStatus{
 				{
 					Application:        "app1",
 					LastTransitionTime: nil,
diff --git a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go
index 618acbd3af103..aaf60eed75585 100644
--- a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go
+++ b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go
@@ -30,7 +30,6 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 
 	"github.com/argoproj/argo-cd/v2/applicationset/services"
-	appsetv1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	appv1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	appclientset "github.com/argoproj/argo-cd/v2/pkg/client/clientset/versioned"
 	"github.com/argoproj/argo-cd/v2/util/cli"
@@ -60,7 +59,6 @@ func NewCommand() *cobra.Command {
 	)
 	scheme := runtime.NewScheme()
 	_ = clientgoscheme.AddToScheme(scheme)
-	_ = appsetv1alpha1.AddToScheme(scheme)
 	_ = appv1alpha1.AddToScheme(scheme)
 	var command = cobra.Command{
 		Use:   "controller",
diff --git a/reposerver/cache/cache_test.go b/reposerver/cache/cache_test.go
index eba901ed76e42..190ddfc78fe09 100644
--- a/reposerver/cache/cache_test.go
+++ b/reposerver/cache/cache_test.go
@@ -11,7 +11,6 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	. "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
-	appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/reposerver/apiclient"
 	cacheutil "github.com/argoproj/argo-cd/v2/util/cache"
 )
@@ -114,7 +113,7 @@ func TestCache_GetAppDetails(t *testing.T) {
 	cache := newFixtures().Cache
 	// cache miss
 	value := &apiclient.RepoAppDetailsResponse{}
-	emptyRefSources := map[string]*appv1.RefTarget{}
+	emptyRefSources := map[string]*RefTarget{}
 	err := cache.GetAppDetails("my-revision", &ApplicationSource{}, emptyRefSources, value, "", nil)
 	assert.Equal(t, ErrCacheMiss, err)
 	res := &apiclient.RepoAppDetailsResponse{Type: "my-type"}
@@ -153,7 +152,7 @@ func TestCachedManifestResponse_HashBehavior(t *testing.T) {
 		Revision:  "revision",
 		Manifests: []string{"sample-text"},
 	}
-	appSrc := &appv1.ApplicationSource{}
+	appSrc := &ApplicationSource{}
 	appKey := "key"
 	appValue := "value"
 
diff --git a/server/applicationset/applicationset.go b/server/applicationset/applicationset.go
index 12d1095b4eafa..abe95358c2a3b 100644
--- a/server/applicationset/applicationset.go
+++ b/server/applicationset/applicationset.go
@@ -28,7 +28,6 @@ import (
 	servercache "github.com/argoproj/argo-cd/v2/server/cache"
 	"github.com/argoproj/argo-cd/v2/server/rbacpolicy"
 	"github.com/argoproj/argo-cd/v2/util/argo"
-	argoutil "github.com/argoproj/argo-cd/v2/util/argo"
 	"github.com/argoproj/argo-cd/v2/util/db"
 	"github.com/argoproj/argo-cd/v2/util/rbac"
 	"github.com/argoproj/argo-cd/v2/util/session"
@@ -115,7 +114,7 @@ func (s *Server) List(ctx context.Context, q *applicationset.ApplicationSetListQ
 		}
 	}
 
-	newItems = argoutil.FilterAppSetsByProjects(newItems, q.Projects)
+	newItems = argo.FilterAppSetsByProjects(newItems, q.Projects)
 
 	// Sort found applicationsets by name
 	sort.Slice(newItems, func(i, j int) bool {
diff --git a/test/e2e/fixture/applicationsets/actions.go b/test/e2e/fixture/applicationsets/actions.go
index a1fa4c40d22c2..956d62ad86707 100644
--- a/test/e2e/fixture/applicationsets/actions.go
+++ b/test/e2e/fixture/applicationsets/actions.go
@@ -17,7 +17,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 
 	"github.com/argoproj/argo-cd/v2/common"
-	argocommon "github.com/argoproj/argo-cd/v2/common"
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/test/e2e/fixture/applicationsets/utils"
 	"github.com/argoproj/argo-cd/v2/util/clusterauth"
@@ -109,8 +108,8 @@ func (a *Actions) CreateClusterSecret(secretName string, clusterName string, clu
 				Name:      secretName,
 				Namespace: fixture.TestNamespace(),
 				Labels: map[string]string{
-					argocommon.LabelKeySecretType: argocommon.LabelValueSecretTypeCluster,
-					utils.TestingLabel:            "true",
+					common.LabelKeySecretType: common.LabelValueSecretTypeCluster,
+					utils.TestingLabel:        "true",
 				},
 			},
 			Data: map[string][]byte{
diff --git a/test/e2e/fixture/applicationsets/consequences.go b/test/e2e/fixture/applicationsets/consequences.go
index 9e70ccbb9ed8f..305a06a4d7174 100644
--- a/test/e2e/fixture/applicationsets/consequences.go
+++ b/test/e2e/fixture/applicationsets/consequences.go
@@ -11,7 +11,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
-	argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/test/e2e/fixture/applicationsets/utils"
 )
 
@@ -61,7 +60,7 @@ func (c *Consequences) When() *Actions {
 	return c.actions
 }
 
-func (c *Consequences) app(name string) *argov1alpha1.Application {
+func (c *Consequences) app(name string) *v1alpha1.Application {
 	apps := c.apps()
 
 	for index, app := range apps {
@@ -73,14 +72,14 @@ func (c *Consequences) app(name string) *argov1alpha1.Application {
 	return nil
 }
 
-func (c *Consequences) apps() []argov1alpha1.Application {
+func (c *Consequences) apps() []v1alpha1.Application {
 
 	fixtureClient := utils.GetE2EFixtureK8sClient()
 	list, err := fixtureClient.AppClientset.ArgoprojV1alpha1().Applications(fixture.TestNamespace()).List(context.Background(), metav1.ListOptions{})
 	errors.CheckError(err)
 
 	if list == nil {
-		list = &argov1alpha1.ApplicationList{}
+		list = &v1alpha1.ApplicationList{}
 	}
 
 	return list.Items
diff --git a/test/e2e/fixture/applicationsets/expectation.go b/test/e2e/fixture/applicationsets/expectation.go
index e8be81b906d7e..fce722b70c9e3 100644
--- a/test/e2e/fixture/applicationsets/expectation.go
+++ b/test/e2e/fixture/applicationsets/expectation.go
@@ -11,7 +11,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
-	argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/test/e2e/fixture/applicationsets/utils"
 )
 
@@ -58,7 +57,7 @@ func Error(message, err string) Expectation {
 
 // ApplicationsExist checks whether each of the 'expectedApps' exist in the namespace, and are
 // equivalent to provided values.
-func ApplicationsExist(expectedApps []argov1alpha1.Application) Expectation {
+func ApplicationsExist(expectedApps []v1alpha1.Application) Expectation {
 	return func(c *Consequences) (state, string) {
 
 		for _, expectedApp := range expectedApps {
@@ -107,7 +106,7 @@ func ApplicationSetHasConditions(applicationSetName string, expectedConditions [
 }
 
 // ApplicationsDoNotExist checks that each of the 'expectedApps' no longer exist in the namespace
-func ApplicationsDoNotExist(expectedApps []argov1alpha1.Application) Expectation {
+func ApplicationsDoNotExist(expectedApps []v1alpha1.Application) Expectation {
 	return func(c *Consequences) (state, string) {
 
 		for _, expectedApp := range expectedApps {
@@ -145,7 +144,7 @@ func pods(namespace string) (*corev1.PodList, error) {
 }
 
 // getDiff returns a string containing a comparison result of two applications (for test output/debug purposes)
-func getDiff(orig, new argov1alpha1.Application) (string, error) {
+func getDiff(orig, new v1alpha1.Application) (string, error) {
 
 	bytes, _, err := diff.CreateTwoWayMergePatch(orig, new, orig)
 	if err != nil {
@@ -177,13 +176,13 @@ func getConditionDiff(orig, new []v1alpha1.ApplicationSetCondition) (string, err
 }
 
 // filterFields returns a copy of Application, but with unnecessary (for testing) fields removed
-func filterFields(input argov1alpha1.Application) argov1alpha1.Application {
+func filterFields(input v1alpha1.Application) v1alpha1.Application {
 
 	spec := input.Spec
 
 	metaCopy := input.ObjectMeta.DeepCopy()
 
-	output := argov1alpha1.Application{
+	output := v1alpha1.Application{
 		ObjectMeta: metav1.ObjectMeta{
 			Labels:      metaCopy.Labels,
 			Annotations: metaCopy.Annotations,
@@ -191,13 +190,13 @@ func filterFields(input argov1alpha1.Application) argov1alpha1.Application {
 			Namespace:   metaCopy.Namespace,
 			Finalizers:  metaCopy.Finalizers,
 		},
-		Spec: argov1alpha1.ApplicationSpec{
-			Source: &argov1alpha1.ApplicationSource{
+		Spec: v1alpha1.ApplicationSpec{
+			Source: &v1alpha1.ApplicationSource{
 				Path:           spec.GetSource().Path,
 				RepoURL:        spec.GetSource().RepoURL,
 				TargetRevision: spec.GetSource().TargetRevision,
 			},
-			Destination: argov1alpha1.ApplicationDestination{
+			Destination: v1alpha1.ApplicationDestination{
 				Server:    spec.Destination.Server,
 				Name:      spec.Destination.Name,
 				Namespace: spec.Destination.Namespace,
@@ -227,7 +226,7 @@ func filterConditionFields(input *[]v1alpha1.ApplicationSetCondition) *[]v1alpha
 }
 
 // appsAreEqual returns true if the apps are equal, comparing only fields of interest
-func appsAreEqual(one argov1alpha1.Application, two argov1alpha1.Application) bool {
+func appsAreEqual(one v1alpha1.Application, two v1alpha1.Application) bool {
 	return reflect.DeepEqual(filterFields(one), filterFields(two))
 }
 
diff --git a/util/argo/diff/diff.go b/util/argo/diff/diff.go
index 59f878036c361..6f32084dadce3 100644
--- a/util/argo/diff/diff.go
+++ b/util/argo/diff/diff.go
@@ -6,7 +6,6 @@ import (
 	"github.com/go-logr/logr"
 
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
-	appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/util/argo"
 	"github.com/argoproj/argo-cd/v2/util/argo/managedfields"
 	appstatecache "github.com/argoproj/argo-cd/v2/util/cache/appstate"
@@ -40,7 +39,7 @@ func (b *DiffConfigBuilder) WithDiffSettings(id []v1alpha1.ResourceIgnoreDiffere
 
 	overrides := o
 	if overrides == nil {
-		overrides = make(map[string]appv1.ResourceOverride)
+		overrides = make(map[string]v1alpha1.ResourceOverride)
 	}
 	b.diffConfig.overrides = overrides
 	b.diffConfig.ignoreAggregatedRoles = ignoreAggregatedRoles
@@ -113,7 +112,7 @@ type DiffConfig interface {
 	Validate() error
 	// DiffFromCache will verify if it should retrieve the cached ResourceDiff based on this
 	// DiffConfig.
-	DiffFromCache(appName string) (bool, []*appv1.ResourceDiff)
+	DiffFromCache(appName string) (bool, []*v1alpha1.ResourceDiff)
 	// Ignores Application level ignore difference configurations.
 	Ignores() []v1alpha1.ResourceIgnoreDifferences
 	// Overrides is map of system configurations to override the Application ones.
@@ -267,13 +266,13 @@ func StateDiffs(lives, configs []*unstructured.Unstructured, diffConfig DiffConf
 	return diff.DiffArray(normResults.Targets, normResults.Lives, diffOpts...)
 }
 
-func diffArrayCached(configArray []*unstructured.Unstructured, liveArray []*unstructured.Unstructured, cachedDiff []*appv1.ResourceDiff, opts ...diff.Option) (*diff.DiffResultList, error) {
+func diffArrayCached(configArray []*unstructured.Unstructured, liveArray []*unstructured.Unstructured, cachedDiff []*v1alpha1.ResourceDiff, opts ...diff.Option) (*diff.DiffResultList, error) {
 	numItems := len(configArray)
 	if len(liveArray) != numItems {
 		return nil, fmt.Errorf("left and right arrays have mismatched lengths")
 	}
 
-	diffByKey := map[kube.ResourceKey]*appv1.ResourceDiff{}
+	diffByKey := map[kube.ResourceKey]*v1alpha1.ResourceDiff{}
 	for i := range cachedDiff {
 		res := cachedDiff[i]
 		diffByKey[kube.NewResourceKey(res.Group, res.Kind, res.Namespace, res.Name)] = cachedDiff[i]
@@ -322,11 +321,11 @@ func diffArrayCached(configArray []*unstructured.Unstructured, liveArray []*unst
 // DiffFromCache will verify if it should retrieve the cached ResourceDiff based on this
 // DiffConfig. Returns true and the cached ResourceDiff if configured to use the cache.
 // Returns false and nil otherwise.
-func (c *diffConfig) DiffFromCache(appName string) (bool, []*appv1.ResourceDiff) {
+func (c *diffConfig) DiffFromCache(appName string) (bool, []*v1alpha1.ResourceDiff) {
 	if c.noCache || c.stateCache == nil || appName == "" {
 		return false, nil
 	}
-	cachedDiff := make([]*appv1.ResourceDiff, 0)
+	cachedDiff := make([]*v1alpha1.ResourceDiff, 0)
 	if c.stateCache != nil && c.stateCache.GetAppManagedResources(appName, &cachedDiff) == nil {
 		return true, cachedDiff
 	}
diff --git a/util/notification/argocd/service.go b/util/notification/argocd/service.go
index d1ef69512b264..61e0bebeca3c6 100644
--- a/util/notification/argocd/service.go
+++ b/util/notification/argocd/service.go
@@ -10,7 +10,6 @@ import (
 
 	"github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
 	"github.com/argoproj/argo-cd/v2/reposerver/apiclient"
-	repoapiclient "github.com/argoproj/argo-cd/v2/reposerver/apiclient"
 	"github.com/argoproj/argo-cd/v2/util/db"
 	"github.com/argoproj/argo-cd/v2/util/settings"
 )
@@ -22,7 +21,7 @@ type Service interface {
 	GetAppDetails(ctx context.Context, appSource *v1alpha1.ApplicationSource) (*shared.AppDetail, error)
 }
 
-func NewArgoCDService(clientset kubernetes.Interface, namespace string, repoClientset repoapiclient.Clientset) (*argoCDService, error) {
+func NewArgoCDService(clientset kubernetes.Interface, namespace string, repoClientset apiclient.Clientset) (*argoCDService, error) {
 	ctx, cancel := context.WithCancel(context.Background())
 	settingsMgr := settings.NewSettingsManager(ctx, clientset, namespace)
 	closer, repoClient, err := repoClientset.NewRepoServerClient()