diff --git a/docs/docs/providers/frontier.md b/docs/docs/providers/frontier.md
index bbd522797..b588e591f 100644
--- a/docs/docs/providers/frontier.md
+++ b/docs/docs/providers/frontier.md
@@ -2,9 +2,9 @@
 
 [Frontier](https://raystack-frontier.vercel.app/) by Raystack is a role-based cloud-native user management system and authorization server for your applications and API endpoints. With Frontier, you can assign roles to users or groups of users to configure policies that determine whether a particular user has the ability to perform a certain action on a given resource. Guardian supports access management to the following resources in Frontier:
 
-1. Team
-2. Project
-3. Organization
+1. Organization
+2. Group
+3. Project
 
 ## Compatible version of Frontier :
 
@@ -38,7 +38,7 @@ credentials:
 allowed_account_types:
   - user
 resources:
-  - type: team
+  - type: group
     policy:
       id: policy_id
       version: 1
@@ -98,9 +98,9 @@ resources:
 
 ### Frontier Resource Type
 
-- team
-- project
 - organization
+- group
+- project
 
 ### Frontier Resource Permission
 
@@ -113,5 +113,5 @@ resources:
 | project           | app_project_owner              | Project Owner               |
 | project           | app_project_manager            | Project Manager             |
 | project           | app_project_member             | Project Member              |
-| team              | app_group_owner                | Group Owner                 |
-| team              | app_group_member               | Group Member                |
+| group             | app_group_owner                | Group Owner                 |
+| group             | app_group_member               | Group Member                |
diff --git a/mocks/FrontierClient.go b/mocks/Client.go
similarity index 81%
rename from mocks/FrontierClient.go
rename to mocks/Client.go
index ffee5b129..80ec3b346 100644
--- a/mocks/FrontierClient.go
+++ b/mocks/Client.go
@@ -12,6 +12,32 @@ type Client struct {
 	mock.Mock
 }
 
+// GetGroups provides a mock function with given fields: orgID
+func (_m *Client) GetGroups(orgID string) ([]*frontier.Group, error) {
+	ret := _m.Called(orgID)
+
+	var r0 []*frontier.Group
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string) ([]*frontier.Group, error)); ok {
+		return rf(orgID)
+	}
+	if rf, ok := ret.Get(0).(func(string) []*frontier.Group); ok {
+		r0 = rf(orgID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*frontier.Group)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(orgID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // GetOrganizations provides a mock function with given fields:
 func (_m *Client) GetOrganizations() ([]*frontier.Organization, error) {
 	ret := _m.Called()
@@ -90,30 +116,18 @@ func (_m *Client) GetSelfUser(email string) (*frontier.User, error) {
 	return r0, r1
 }
 
-// GetTeams provides a mock function with given fields: orgID
-func (_m *Client) GetTeams(orgID string) ([]*frontier.Team, error) {
-	ret := _m.Called(orgID)
-
-	var r0 []*frontier.Team
-	var r1 error
-	if rf, ok := ret.Get(0).(func(string) ([]*frontier.Team, error)); ok {
-		return rf(orgID)
-	}
-	if rf, ok := ret.Get(0).(func(string) []*frontier.Team); ok {
-		r0 = rf(orgID)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*frontier.Team)
-		}
-	}
+// GrantGroupAccess provides a mock function with given fields: group, userId, role
+func (_m *Client) GrantGroupAccess(group *frontier.Group, userId string, role string) error {
+	ret := _m.Called(group, userId, role)
 
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(orgID)
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*frontier.Group, string, string) error); ok {
+		r0 = rf(group, userId, role)
 	} else {
-		r1 = ret.Error(1)
+		r0 = ret.Error(0)
 	}
 
-	return r0, r1
+	return r0
 }
 
 // GrantOrganizationAccess provides a mock function with given fields: organization, userId, role
@@ -144,13 +158,13 @@ func (_m *Client) GrantProjectAccess(project *frontier.Project, userId string, r
 	return r0
 }
 
-// GrantTeamAccess provides a mock function with given fields: team, userId, role
-func (_m *Client) GrantTeamAccess(team *frontier.Team, userId string, role string) error {
-	ret := _m.Called(team, userId, role)
+// RevokeGroupAccess provides a mock function with given fields: group, userId, role
+func (_m *Client) RevokeGroupAccess(group *frontier.Group, userId string, role string) error {
+	ret := _m.Called(group, userId, role)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(*frontier.Team, string, string) error); ok {
-		r0 = rf(team, userId, role)
+	if rf, ok := ret.Get(0).(func(*frontier.Group, string, string) error); ok {
+		r0 = rf(group, userId, role)
 	} else {
 		r0 = ret.Error(0)
 	}
@@ -186,20 +200,6 @@ func (_m *Client) RevokeProjectAccess(project *frontier.Project, userId string,
 	return r0
 }
 
-// RevokeTeamAccess provides a mock function with given fields: team, userId, role
-func (_m *Client) RevokeTeamAccess(team *frontier.Team, userId string, role string) error {
-	ret := _m.Called(team, userId, role)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*frontier.Team, string, string) error); ok {
-		r0 = rf(team, userId, role)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
 // NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
 func NewClient(t interface {
diff --git a/plugins/providers/frontier/client.go b/plugins/providers/frontier/client.go
index 3586e4394..6068ecba3 100644
--- a/plugins/providers/frontier/client.go
+++ b/plugins/providers/frontier/client.go
@@ -36,11 +36,11 @@ type Policy struct {
 }
 
 type Client interface {
-	GetTeams(orgID string) ([]*Team, error)
+	GetGroups(orgID string) ([]*Group, error)
 	GetProjects(orgID string) ([]*Project, error)
 	GetOrganizations() ([]*Organization, error)
-	GrantTeamAccess(team *Team, userId string, role string) error
-	RevokeTeamAccess(team *Team, userId string, role string) error
+	GrantGroupAccess(group *Group, userId string, role string) error
+	RevokeGroupAccess(group *Group, userId string, role string) error
 	GrantProjectAccess(project *Project, userId string, role string) error
 	RevokeProjectAccess(project *Project, userId string, role string) error
 	GrantOrganizationAccess(organization *Organization, userId string, role string) error
@@ -148,34 +148,34 @@ func (c *client) GetAdminsOfGivenResourceType(id string, resourceTypeEndPoint st
 	return userEmails, err
 }
 
-func (c *client) GetTeams(orgID string) ([]*Team, error) {
+func (c *client) GetGroups(orgID string) ([]*Group, error) {
 	groupsEndpoint := fmt.Sprintf(groupsEndpoint, orgID)
 	req, err := c.newRequest(http.MethodGet, groupsEndpoint, nil, "")
 	if err != nil {
 		return nil, err
 	}
 
-	var teams []*Team
+	var groups []*Group
 	var response interface{}
 	if _, err := c.do(req, &response); err != nil {
 		return nil, err
 	}
 
 	if v, ok := response.(map[string]interface{}); ok && v[groupsConst] != nil {
-		err = mapstructure.Decode(v[groupsConst], &teams)
+		err = mapstructure.Decode(v[groupsConst], &groups)
 	}
 
-	for _, team := range teams {
-		admins, err := c.GetAdminsOfGivenResourceType(team.ID, groupsEndpoint)
+	for _, group := range groups {
+		admins, err := c.GetAdminsOfGivenResourceType(group.ID, groupsEndpoint)
 		if err != nil {
 			return nil, err
 		}
-		team.Admins = admins
+		group.Admins = admins
 	}
 
-	c.logger.Info("Fetch teams from request", "total", len(teams), req.URL)
+	c.logger.Info("Fetch groups from request", "total", len(groups), req.URL)
 
-	return teams, err
+	return groups, err
 }
 
 func (c *client) GetProjects(orgID string) ([]*Project, error) {
@@ -238,7 +238,7 @@ func (c *client) GetOrganizations() ([]*Organization, error) {
 	return organizations, err
 }
 
-func (c *client) GrantTeamAccess(resource *Team, userId string, role string) error {
+func (c *client) GrantGroupAccess(resource *Group, userId string, role string) error {
 	body := make(map[string]string)
 	body["principal"] = fmt.Sprintf("%s:%s", "app/user", userId)
 	body["resource"] = fmt.Sprintf("%s:%s", "app/group", resource.ID)
@@ -301,7 +301,7 @@ func (c *client) GrantOrganizationAccess(resource *Organization, userId string,
 	return nil
 }
 
-func (c *client) RevokeTeamAccess(resource *Team, userId string, role string) error {
+func (c *client) RevokeGroupAccess(resource *Group, userId string, role string) error {
 	endpoint := createPolicyEndpoint + "?groupId=" + resource.ID + "&userId=" + userId + "&roleId=" + role
 	req, err := c.newRequest(http.MethodGet, endpoint, "", "")
 	if err != nil {
diff --git a/plugins/providers/frontier/client_test.go b/plugins/providers/frontier/client_test.go
index b46f1ee5d..578c55803 100644
--- a/plugins/providers/frontier/client_test.go
+++ b/plugins/providers/frontier/client_test.go
@@ -117,80 +117,80 @@ func (s *ClientTestSuite) getTestRequest(method, path string, body interface{},
 	return req, nil
 }
 
-func (s *ClientTestSuite) TestGetTeams() {
-	s.Run("should get teams and nil error on success", func() {
+func (s *ClientTestSuite) TestGetGroups() {
+	s.Run("should get groups and nil error on success", func() {
 		s.setup()
 
 		testRequest, err := s.getTestRequest(http.MethodGet, "/v1beta1/organizations/org_id_1/groups", nil, "")
 		s.Require().NoError(err)
 
-		teamResponseJSON := `{
+		groupResponseJSON := `{
 		    "groups": [
 		        {
-		            "id": "team_id_1",
-		            "name": "team_1",
-		            "title": "team_1",
+		            "id": "group_id_1",
+		            "name": "group_1",
+		            "title": "group_1",
 		            "orgId": "org_id_1",
 		            "metadata": {
-		                "email": "team_1@email.com",
+		                "email": "group_1@email.com",
 		                "privacy": "public",
-		                "slack": "@team_1"
+		                "slack": "@group_1"
 		            },
 		            "createdAt": "2022-03-17T06:19:47.176089Z",
 		            "updatedAt": "2022-03-17T06:19:47.176089Z"
 		        },
 		        {
-		            "id": "team_id_2",
-		            "name": "team_2",
-		            "title": "team_2",
+		            "id": "group_id_2",
+		            "name": "group_2",
+		            "title": "group_2",
 		            "orgId": "org_id_1",
 		            "metadata": {
-		                "email": "team_2@email.com",
+		                "email": "group_2@email.com",
 		                "privacy": "public",
-		                "slack": "@team_2"
+		                "slack": "@group_2"
 		            },
 		            "createdAt": "2022-03-30T10:49:10.965916Z",
 		            "updatedAt": "2022-03-30T10:49:10.965916Z"
 		        }
 		    ]
 		}`
-		teamResponse := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(teamResponseJSON)))}
-		s.mockHttpClient.On("Do", testRequest).Return(&teamResponse, nil).Once()
+		groupResponse := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(groupResponseJSON)))}
+		s.mockHttpClient.On("Do", testRequest).Return(&groupResponse, nil).Once()
 
-		expectedTeams := []frontier.Team{
+		expectedTeams := []frontier.Group{
 			{
-				ID:    "team_id_1",
-				Name:  "team_1",
-				Title: "team_1",
+				ID:    "group_id_1",
+				Name:  "group_1",
+				Title: "group_1",
 				OrgId: "org_id_1",
 				Metadata: frontier.Metadata{
-					Email:   "team_1@email.com",
+					Email:   "group_1@email.com",
 					Privacy: "public",
-					Slack:   "@team_1",
+					Slack:   "@group_1",
 				},
 				Admins: []string{"test.admin@email.com"},
 			},
 			{
-				ID:    "team_id_2",
-				Name:  "team_2",
-				Title: "team_2",
+				ID:    "group_id_2",
+				Name:  "group_2",
+				Title: "group_2",
 				OrgId: "org_id_1",
 				Metadata: frontier.Metadata{
-					Email:   "team_2@email.com",
+					Email:   "group_2@email.com",
 					Privacy: "public",
-					Slack:   "@team_2",
+					Slack:   "@group_2",
 				},
 				Admins: []string{"test.admin@email.com"},
 			},
 		}
 
-		testAdminsRequest1, err := s.getTestRequest(http.MethodGet, "/v1beta1/organizations/org_id_1/groups/team_id_1/admins", nil, "")
+		testAdminsRequest1, err := s.getTestRequest(http.MethodGet, "/v1beta1/organizations/org_id_1/groups/group_id_1/admins", nil, "")
 		s.Require().NoError(err)
 
-		testAdminsRequest2, err := s.getTestRequest(http.MethodGet, "/v1beta1/organizations/org_id_1/groups/team_id_2/admins", nil, "")
+		testAdminsRequest2, err := s.getTestRequest(http.MethodGet, "/v1beta1/organizations/org_id_1/groups/group_id_2/admins", nil, "")
 		s.Require().NoError(err)
 
-		teamAdminResponse := `{
+		groupAdminResponse := `{
 			"users": [
 				{
 					"id": "admin_id",
@@ -205,19 +205,19 @@ func (s *ClientTestSuite) TestGetTeams() {
 				}]
 		}`
 
-		teamAdminResponse1 := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(teamAdminResponse)))}
-		s.mockHttpClient.On("Do", testAdminsRequest1).Return(&teamAdminResponse1, nil).Once()
+		groupAdminResponse1 := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(groupAdminResponse)))}
+		s.mockHttpClient.On("Do", testAdminsRequest1).Return(&groupAdminResponse1, nil).Once()
 
-		teamAdminResponse2 := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(teamAdminResponse)))}
-		s.mockHttpClient.On("Do", testAdminsRequest2).Return(&teamAdminResponse2, nil).Once()
+		groupAdminResponse2 := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(groupAdminResponse)))}
+		s.mockHttpClient.On("Do", testAdminsRequest2).Return(&groupAdminResponse2, nil).Once()
 
-		result, err1 := s.client.GetTeams("org_id_1")
-		var teams []frontier.Team
-		for _, team := range result {
-			teams = append(teams, *team)
+		result, err1 := s.client.GetGroups("org_id_1")
+		var groups []frontier.Group
+		for _, group := range result {
+			groups = append(groups, *group)
 		}
 		s.Nil(err1)
-		s.ElementsMatch(expectedTeams, teams)
+		s.ElementsMatch(expectedTeams, groups)
 	})
 }
 
@@ -305,7 +305,7 @@ func (s *ClientTestSuite) TestGetOrganizations() {
 		            "title": "org_1",
 		            "metadata": {
 		                "dwh_group_id": "dwh_group",
-                		"dwh_team_name": "dwh_team"
+                		"dwh_group_name": "dwh_group"
 		            },
 		            "createdAt": "2022-03-17T06:19:47.176089Z",
 		            "updatedAt": "2022-03-17T06:19:47.176089Z"
@@ -357,18 +357,18 @@ func (s *ClientTestSuite) TestGetOrganizations() {
 }
 
 func (s *ClientTestSuite) TestGrantTeamAccess() {
-	s.Run("should grant access to team and nil error on success", func() {
+	s.Run("should grant access to group and nil error on success", func() {
 		s.setup()
 
 		testUserId := "test_user_id"
-		var teamObj *frontier.Team
-		teamObj = new(frontier.Team)
-		teamObj.ID = "test_team_id"
+		var groupObj *frontier.Group
+		groupObj = new(frontier.Group)
+		groupObj.ID = "test_group_id"
 		role := "users"
 
 		body := make(map[string]string)
 		body["principal"] = fmt.Sprintf("%s:%s", "app/user", testUserId)
-		body["resource"] = fmt.Sprintf("%s:%s", "app/group", teamObj.ID)
+		body["resource"] = fmt.Sprintf("%s:%s", "app/group", groupObj.ID)
 		body["roleId"] = role
 
 		responseJson := `{}`
@@ -376,7 +376,7 @@ func (s *ClientTestSuite) TestGrantTeamAccess() {
 		responseUsers := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(responseJson)))}
 		s.mockHttpClient.On("Do", mock.AnythingOfType("*http.Request")).Return(&responseUsers, nil).Once()
 
-		actualError := s.client.GrantTeamAccess(teamObj, testUserId, role)
+		actualError := s.client.GrantGroupAccess(groupObj, testUserId, role)
 		s.Nil(actualError)
 	})
 }
@@ -431,13 +431,13 @@ func (s *ClientTestSuite) TestGrantOrganizationAccess() {
 }
 
 func (s *ClientTestSuite) TestRevokeTeamAccess() {
-	s.Run("should revoke access to team and nil error on success", func() {
+	s.Run("should revoke access to group and nil error on success", func() {
 		s.setup()
 		testUserId := "test_user_id"
 		role := frontier.RoleGroupMember
-		var teamObj *frontier.Team
-		teamObj = new(frontier.Team)
-		teamObj.ID = "test_team_id"
+		var groupObj *frontier.Group
+		groupObj = new(frontier.Group)
+		groupObj.ID = "test_group_id"
 
 		responseJson := `{
 			"policies": [
@@ -453,7 +453,7 @@ func (s *ClientTestSuite) TestRevokeTeamAccess() {
 		deletePolicyResp := http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewReader([]byte(responseJson)))}
 		s.mockHttpClient.On("Do", mock.Anything).Return(&deletePolicyResp, nil).Once()
 
-		actualError := s.client.RevokeTeamAccess(teamObj, testUserId, role)
+		actualError := s.client.RevokeGroupAccess(groupObj, testUserId, role)
 		s.Nil(actualError)
 	})
 }
diff --git a/plugins/providers/frontier/config.go b/plugins/providers/frontier/config.go
index 8d60fe4fc..040836f7a 100644
--- a/plugins/providers/frontier/config.go
+++ b/plugins/providers/frontier/config.go
@@ -94,7 +94,7 @@ func (c *Config) validateCredentials(value interface{}) (*Credentials, error) {
 }
 
 func (c *Config) validateResourceConfig(resource *domain.ResourceConfig) error {
-	resourceTypeValidation := fmt.Sprintf("oneof=%s %s %s", ResourceTypeTeam, ResourceTypeProject, ResourceTypeOrganization)
+	resourceTypeValidation := fmt.Sprintf("oneof=%s %s %s", ResourceTypeGroup, ResourceTypeProject, ResourceTypeOrganization)
 	if err := c.validator.Var(resource.Type, resourceTypeValidation); err != nil {
 		return err
 	}
@@ -124,7 +124,7 @@ func (c *Config) validatePermission(resourceType string, value interface{}) (*Pe
 	}
 
 	var nameValidation string
-	if resourceType == ResourceTypeTeam {
+	if resourceType == ResourceTypeGroup {
 		nameValidation = fmt.Sprintf("oneof=%s %s", RoleGroupOwner, RoleGroupMember)
 	} else if resourceType == ResourceTypeProject {
 		nameValidation = fmt.Sprintf("oneof=%s %s %s", RoleProjectManager, RoleProjectOwner, RoleProjectViewer)
diff --git a/plugins/providers/frontier/config_test.go b/plugins/providers/frontier/config_test.go
index b2c3c9e25..dae096267 100644
--- a/plugins/providers/frontier/config_test.go
+++ b/plugins/providers/frontier/config_test.go
@@ -31,10 +31,10 @@ func TestValidate(t *testing.T) {
 
 	validResourceConfig := []*domain.ResourceConfig{
 		{
-			Type: frontier.ResourceTypeTeam,
+			Type: frontier.ResourceTypeGroup,
 			Roles: []*domain.Role{
 				{
-					Permissions: []interface{}{"users", "admins"},
+					Permissions: []interface{}{frontier.RoleGroupMember, frontier.RoleGroupOwner},
 				},
 			},
 		},
@@ -42,7 +42,7 @@ func TestValidate(t *testing.T) {
 			Type: frontier.ResourceTypeProject,
 			Roles: []*domain.Role{
 				{
-					Permissions: []interface{}{"admins"},
+					Permissions: []interface{}{frontier.RoleProjectOwner, frontier.RoleProjectManager, frontier.RoleProjectViewer},
 				},
 			},
 		},
@@ -50,7 +50,7 @@ func TestValidate(t *testing.T) {
 			Type: frontier.ResourceTypeOrganization,
 			Roles: []*domain.Role{
 				{
-					Permissions: []interface{}{"admins"},
+					Permissions: []interface{}{frontier.RoleOrgOwner, frontier.RoleOrgManager, frontier.RoleOrgAccessManager, frontier.RoleOrgViewer},
 				},
 			},
 		},
@@ -58,7 +58,7 @@ func TestValidate(t *testing.T) {
 
 	inValidResourcePermissionConfig := []*domain.ResourceConfig{
 		{
-			Type: frontier.ResourceTypeTeam,
+			Type: frontier.ResourceTypeGroup,
 			Roles: []*domain.Role{
 				{
 					Permissions: []interface{}{"member"},
diff --git a/plugins/providers/frontier/provider.go b/plugins/providers/frontier/provider.go
index 93e095c71..5f33e4184 100644
--- a/plugins/providers/frontier/provider.go
+++ b/plugins/providers/frontier/provider.go
@@ -57,7 +57,7 @@ func (p *provider) GetResources(pc *domain.ProviderConfig) ([]*domain.Resource,
 
 	resources := []*domain.Resource{}
 
-	var teams []*Team
+	var groups []*Group
 	var projects []*Project
 	var organizations []*Organization
 
@@ -76,12 +76,12 @@ func (p *provider) GetResources(pc *domain.ProviderConfig) ([]*domain.Resource,
 				resources = p.addProjects(pc, projects, resources)
 			}
 
-			if _, ok := resourceTypes[ResourceTypeTeam]; ok {
-				teams, err = client.GetTeams(orgs.ID)
+			if _, ok := resourceTypes[ResourceTypeGroup]; ok {
+				groups, err = client.GetGroups(orgs.ID)
 				if err != nil {
 					return nil, err
 				}
-				resources = p.addTeams(pc, teams, resources)
+				resources = p.addGroups(pc, groups, resources)
 			}
 		}
 	}
@@ -89,8 +89,8 @@ func (p *provider) GetResources(pc *domain.ProviderConfig) ([]*domain.Resource,
 	return resources, nil
 }
 
-func (p *provider) addTeams(pc *domain.ProviderConfig, teams []*Team, resources []*domain.Resource) []*domain.Resource {
-	for _, c := range teams {
+func (p *provider) addGroups(pc *domain.ProviderConfig, groups []*Group, resources []*domain.Resource) []*domain.Resource {
+	for _, c := range groups {
 		t := c.ToDomain()
 		t.ProviderType = pc.Type
 		t.ProviderURN = pc.URN
@@ -160,13 +160,13 @@ func (p *provider) GrantAccess(pc *domain.ProviderConfig, a domain.Grant) error
 	}
 
 	switch a.Resource.Type {
-	case ResourceTypeTeam:
-		t := new(Team)
+	case ResourceTypeGroup:
+		t := new(Group)
 		if err := t.FromDomain(a.Resource); err != nil {
 			return err
 		}
 		for _, p := range permissions {
-			if err := client.GrantTeamAccess(t, user.ID, p); err != nil {
+			if err := client.GrantGroupAccess(t, user.ID, p); err != nil {
 				return err
 			}
 		}
@@ -216,13 +216,13 @@ func (p *provider) RevokeAccess(pc *domain.ProviderConfig, a domain.Grant) error
 	}
 
 	switch a.Resource.Type {
-	case ResourceTypeTeam:
-		t := new(Team)
+	case ResourceTypeGroup:
+		t := new(Group)
 		if err := t.FromDomain(a.Resource); err != nil {
 			return err
 		}
 		for _, p := range permissions {
-			if err := client.RevokeTeamAccess(t, user.ID, p); err != nil {
+			if err := client.RevokeGroupAccess(t, user.ID, p); err != nil {
 				return err
 			}
 		}
diff --git a/plugins/providers/frontier/provider_test.go b/plugins/providers/frontier/provider_test.go
index 94ff8d114..72837ef5b 100644
--- a/plugins/providers/frontier/provider_test.go
+++ b/plugins/providers/frontier/provider_test.go
@@ -1,1463 +1,1463 @@
 package frontier_test
 
-import (
-	"errors"
-	"testing"
-
-	"github.com/raystack/salt/log"
-
-	"github.com/raystack/guardian/core/provider"
-	"github.com/raystack/guardian/domain"
-	"github.com/raystack/guardian/mocks"
-	"github.com/raystack/guardian/plugins/providers/frontier"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-)
-
-func TestGetType(t *testing.T) {
-	t.Run("should return provider type name", func(t *testing.T) {
-		expectedTypeName := domain.ProviderTypeFrontier
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider(expectedTypeName, logger)
-
-		actualTypeName := p.GetType()
-
-		assert.Equal(t, expectedTypeName, actualTypeName)
-	})
-}
-
-func TestCreateConfig(t *testing.T) {
-	t.Run("should return error if there resource config is invalid", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		testcases := []struct {
-			pc *domain.ProviderConfig
-		}{
-			{
-				pc: &domain.ProviderConfig{
-					Credentials: frontier.Credentials{
-						Host:      "localhost",
-						AuthEmail: "test-email",
-					},
-					Resources: []*domain.ResourceConfig{
-						{
-							Type: "invalid resource type",
-						},
-					},
-				},
-			},
-			{
-				pc: &domain.ProviderConfig{
-					Credentials: frontier.Credentials{
-						Host:      "localhost",
-						AuthEmail: "test-email",
-					},
-					Resources: []*domain.ResourceConfig{
-						{
-							Type: frontier.ResourceTypeTeam,
-							Roles: []*domain.Role{
-								{
-									ID:          "member",
-									Permissions: []interface{}{"wrong permissions"},
-								},
-							},
-						},
-					},
-				},
-			},
-		}
-
-		for _, tc := range testcases {
-			actualError := p.CreateConfig(tc.pc)
-			assert.Error(t, actualError)
-		}
-	})
-
-	t.Run("should not return error if parse and valid of Credentials are correct", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		testcases := []struct {
-			pc            *domain.ProviderConfig
-			expectedError error
-		}{
-			{
-				pc: &domain.ProviderConfig{
-					Credentials: frontier.Credentials{
-						Host:       "localhost",
-						AuthEmail:  "test-email",
-						AuthHeader: "X-Frontier-Email",
-					},
-					Resources: []*domain.ResourceConfig{
-						{
-							Type: frontier.ResourceTypeTeam,
-							Roles: []*domain.Role{
-								{
-									ID: "member",
-									Permissions: []interface{}{
-										frontier.RoleGroupMember,
-									},
-								},
-								{
-									ID: "admin",
-									Permissions: []interface{}{
-										frontier.RoleGroupOwner,
-									},
-								},
-							},
-						},
-					},
-					URN: providerURN,
-				},
-				expectedError: nil,
-			},
-			{
-				pc: &domain.ProviderConfig{
-					Credentials: frontier.Credentials{
-						Host:       "localhost",
-						AuthEmail:  "test-email",
-						AuthHeader: "X-Frontier-Email",
-					},
-					Resources: []*domain.ResourceConfig{
-						{
-							Type: frontier.ResourceTypeProject,
-							Roles: []*domain.Role{
-								{
-									ID: "admin",
-									Permissions: []interface{}{
-										frontier.RoleProjectOwner,
-									},
-								},
-							},
-						},
-					},
-					URN: providerURN,
-				},
-				expectedError: nil,
-			},
-			{
-				pc: &domain.ProviderConfig{
-					Credentials: frontier.Credentials{
-						Host:       "localhost",
-						AuthEmail:  "test-email",
-						AuthHeader: "X-Frontier-Email",
-					},
-					Resources: []*domain.ResourceConfig{
-						{
-							Type: frontier.ResourceTypeOrganization,
-							Roles: []*domain.Role{
-								{
-									ID:          "admin",
-									Permissions: []interface{}{frontier.RoleOrgOwner},
-								},
-							},
-						},
-					},
-					URN: providerURN,
-				},
-				expectedError: nil,
-			},
-		}
-
-		for _, tc := range testcases {
-			actualError := p.CreateConfig(tc.pc)
-			assert.Equal(t, tc.expectedError, actualError)
-		}
-	})
-}
-
-func TestGetResources(t *testing.T) {
-	t.Run("should return error if credentials is invalid", func(t *testing.T) {
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-
-		pc := &domain.ProviderConfig{
-			Credentials: "invalid-creds",
-		}
-
-		actualResources, actualError := p.GetResources(pc)
-
-		assert.Nil(t, actualResources)
-		assert.Error(t, actualError)
-	})
-
-	t.Run("should return error if got any on getting team resources", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		pc := &domain.ProviderConfig{
-			URN:         providerURN,
-			Credentials: map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: frontier.ResourceTypeOrganization,
-				},
-				{
-					Type: frontier.ResourceTypeTeam,
-				},
-			},
-		}
-		expectedError := errors.New("client error")
-		expectedOrganizations := []*frontier.Organization{
-			{
-				ID:     "org_id",
-				Name:   "org_1",
-				Admins: []string{"testOrganizationAdmin@gmail.com"},
-			},
-		}
-
-		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
-		client.On("GetTeams", "org_id").Return(nil, expectedError).Once()
-
-		actualResources, actualError := p.GetResources(pc)
-
-		assert.Nil(t, actualResources)
-		assert.EqualError(t, actualError, expectedError.Error())
-	})
-
-	t.Run("should return error if got any on getting project resources", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		pc := &domain.ProviderConfig{
-			URN:         providerURN,
-			Credentials: map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: frontier.ResourceTypeOrganization,
-				},
-				{
-					Type: frontier.ResourceTypeProject,
-				},
-			},
-		}
-
-		expectedOrganizations := []*frontier.Organization{
-			{
-				ID:     "org_id",
-				Name:   "org_1",
-				Admins: []string{"testOrganizationAdmin@gmail.com"},
-			},
-		}
-
-		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
-
-		expectedError := errors.New("client error")
-		client.On("GetProjects", "org_id").Return(nil, expectedError).Once()
-
-		actualResources, actualError := p.GetResources(pc)
-
-		assert.Nil(t, actualResources)
-		assert.EqualError(t, actualError, expectedError.Error())
-	})
-
-	t.Run("should return error if got any on getting organization resources", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		pc := &domain.ProviderConfig{
-			URN:         providerURN,
-			Credentials: map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: frontier.ResourceTypeOrganization,
-				},
-			},
-		}
-		expectedError := errors.New("client error")
-		client.On("GetOrganizations").Return(nil, expectedError).Once()
-
-		actualResources, actualError := p.GetResources(pc)
-
-		assert.Nil(t, actualResources)
-		assert.EqualError(t, actualError, expectedError.Error())
-	})
-
-	t.Run("should return list of resources and nil error on success", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		pc := &domain.ProviderConfig{
-			URN:         providerURN,
-			Credentials: map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: frontier.ResourceTypeTeam,
-				},
-				{
-					Type: frontier.ResourceTypeProject,
-				},
-				{
-					Type: frontier.ResourceTypeOrganization,
-				},
-			},
-		}
-
-		expectedOrganizations := []*frontier.Organization{
-			{
-				ID:     "org_id",
-				Name:   "org_1",
-				Admins: []string{"testOrganizationAdmin@gmail.com"},
-			},
-		}
-
-		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
-
-		expectedTeams := []*frontier.Team{
-			{
-				ID:    "team_id",
-				Name:  "team_1",
-				OrgId: "org_id",
-				Metadata: frontier.Metadata{
-					Email:   "team_1@raystack.org",
-					Privacy: "public",
-					Slack:   "team_1_slack",
-				},
-				Admins: []string{"testTeamAdmin@gmail.com"},
-			},
-		}
-		client.On("GetTeams", "org_id").Return(expectedTeams, nil).Once()
-
-		expectedProjects := []*frontier.Project{
-			{
-				ID:     "project_id",
-				Name:   "project_1",
-				OrgId:  "org_id",
-				Admins: []string{"testProjectAdmin@gmail.com"},
-			},
-		}
-		client.On("GetProjects", "org_id").Return(expectedProjects, nil).Once()
-
-		expectedResources := []*domain.Resource{
-			{
-				Type:        frontier.ResourceTypeOrganization,
-				URN:         "organization:org_id",
-				ProviderURN: providerURN,
-				Name:        "org_1",
-				Details: map[string]interface{}{
-					"id":     "org_id",
-					"admins": []string{"testOrganizationAdmin@gmail.com"},
-				},
-			},
-			{
-				Type:        frontier.ResourceTypeProject,
-				URN:         "project:project_id",
-				ProviderURN: providerURN,
-				Name:        "project_1",
-				Details: map[string]interface{}{
-					"id":     "project_id",
-					"orgId":  "org_id",
-					"admins": []string{"testProjectAdmin@gmail.com"},
-				},
-			},
-			{
-				Type:        frontier.ResourceTypeTeam,
-				URN:         "team:team_id",
-				ProviderURN: providerURN,
-				Name:        "team_1",
-				Details: map[string]interface{}{
-					"id":     "team_id",
-					"orgId":  "org_id",
-					"admins": []string{"testTeamAdmin@gmail.com"},
-					"metadata": frontier.Metadata{
-						Email:   "team_1@raystack.org",
-						Privacy: "public",
-						Slack:   "team_1_slack",
-					},
-				},
-			},
-		}
-
-		actualResources, actualError := p.GetResources(pc)
-
-		assert.Equal(t, expectedResources, actualResources)
-		assert.Nil(t, actualError)
-	})
-}
-
-func TestGrantAccess(t *testing.T) {
-	t.Run("should return error if credentials is invalid", func(t *testing.T) {
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-
-		pc := &domain.ProviderConfig{
-			Credentials: "invalid-credentials",
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "test-type",
-					Roles: []*domain.Role{
-						{
-							ID:          "test-role",
-							Permissions: []interface{}{"test-permission-config"},
-						},
-					},
-				},
-			},
-		}
-		a := domain.Grant{
-			Resource: &domain.Resource{
-				Type: "test-type",
-			},
-			Role: "test-role",
-		}
-
-		actualError := p.GrantAccess(pc, a)
-		assert.Error(t, actualError)
-	})
-
-	t.Run("should return error if resource type in unknown", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		expectedError := errors.New("invalid resource type")
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		expectedUserEmail := "test@email.com"
-		expectedUser := &frontier.User{
-			ID:    "test_user_id",
-			Name:  "test_user",
-			Email: expectedUserEmail,
-		}
-
-		client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-
-		pc := &domain.ProviderConfig{
-			Credentials: frontier.Credentials{
-				Host:       "http://localhost/",
-				AuthHeader: "X-Frontier-Email",
-				AuthEmail:  "test-email",
-			},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "test-type",
-					Roles: []*domain.Role{
-						{
-							ID:          "test-role",
-							Permissions: []interface{}{"test-permission-config"},
-						},
-					},
-				},
-			},
-			URN: providerURN,
-		}
-
-		a := domain.Grant{
-			Resource: &domain.Resource{
-				Type: "test-type",
-			},
-			Role:      "test-role",
-			AccountID: expectedUserEmail,
-		}
-
-		actualError := p.GrantAccess(pc, a)
-
-		assert.EqualError(t, actualError, expectedError.Error())
-	})
-
-	t.Run("given team resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in granting team access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantTeamAccess", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:       "localhost",
-					AuthHeader: "X-Frontier-Email",
-					AuthEmail:  "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeTeam,
-						Roles: []*domain.Role{
-							{
-								ID:          "test-role",
-								Permissions: []interface{}{"test-permission-config"},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeTeam,
-					URN:  "team:team_id",
-					Name: "team_1",
-					Details: map[string]interface{}{
-						"id":     "team_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-						"metadata": frontier.Metadata{
-							Email:   "team_1@raystack.org",
-							Privacy: "public",
-							Slack:   "team_1_slack",
-						},
-					},
-				},
-				Role:      "test-role",
-				AccountID: expectedUserEmail,
-				Permissions: []string{
-					frontier.RoleGroupMember,
-				},
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			client := mocks.NewClient(t)
-			expectedTeam := &frontier.Team{
-				Name:   "team_1",
-				ID:     "team_id",
-				OrgId:  "456",
-				Admins: []string{"testAdmin@email.com"},
-				Metadata: frontier.Metadata{
-					Email:   "team_1@raystack.org",
-					Privacy: "public",
-					Slack:   "team_1_slack",
-				},
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			expectedRole := frontier.RoleGroupMember
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantTeamAccess", expectedTeam, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:       "localhost",
-					AuthHeader: "X-Frontier-Email",
-					AuthEmail:  "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeTeam,
-						Roles: []*domain.Role{
-							{
-								ID:          "member",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeTeam,
-					URN:  "team:team_id",
-					Name: "team_1",
-					Details: map[string]interface{}{
-						"id":     "team_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-						"metadata": frontier.Metadata{
-							Email:   "team_1@raystack.org",
-							Privacy: "public",
-							Slack:   "team_1_slack",
-						},
-					},
-				},
-				Role:        "member",
-				Permissions: []string{frontier.RoleGroupMember},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.Nil(t, actualError)
-		})
-	})
-
-	t.Run("given project resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in granting project access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantProjectAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:       "localhost",
-					AuthHeader: "X-Frontier-Email",
-					AuthEmail:  "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeProject,
-						Roles: []*domain.Role{
-							{
-								ID:          "test-role",
-								Permissions: []interface{}{"test-permission-config"},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeProject,
-					URN:  "project:project_id",
-					Name: "project_1",
-					Details: map[string]interface{}{
-						"id":     "project_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "test-role",
-				AccountID:   expectedUserEmail,
-				Permissions: []string{"test-permission-config"},
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			client := mocks.NewClient(t)
-			expectedProject := &frontier.Project{
-				Name:   "project_1",
-				ID:     "project_id",
-				OrgId:  "456",
-				Admins: []string{},
-			}
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			expectedRole := frontier.RoleProjectOwner
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantProjectAccess", expectedProject, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:       "localhost",
-					AuthHeader: "X-Frontier-Email",
-					AuthEmail:  "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeProject,
-						Roles: []*domain.Role{
-							{
-								ID:          "admin",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeProject,
-					URN:  "project:project_id",
-					Name: "project_1",
-					Details: map[string]interface{}{
-						"id":                  "project_id",
-						"orgId":               "456",
-						frontier.RoleOrgOwner: []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "admin",
-				Permissions: []string{frontier.RoleProjectOwner},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.Nil(t, actualError)
-		})
-	})
-
-	t.Run("given organization resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in granting organization access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantOrganizationAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeOrganization,
-						Roles: []*domain.Role{
-							{
-								ID: "test-role",
-								Permissions: []interface{}{
-									frontier.RoleOrgOwner,
-								},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeOrganization,
-					URN:  "organization:org_id",
-					Name: "org_1",
-					Details: map[string]interface{}{
-						"id":     "org_id",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "test-role",
-				Permissions: []string{frontier.RoleOrgOwner},
-				AccountID:   expectedUserEmail,
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			client := mocks.NewClient(t)
-			expectedOrganization := &frontier.Organization{
-				Name:   "org_1",
-				ID:     "org_id",
-				Admins: []string{"testAdmin@email.com"},
-			}
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			expectedRole := frontier.RoleOrgOwner
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("GrantOrganizationAccess", expectedOrganization, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeOrganization,
-						Roles: []*domain.Role{
-							{
-								ID:          "admin",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeOrganization,
-					URN:  "organization:org_id",
-					Name: "org_1",
-					Details: map[string]interface{}{
-						"id":     "org_id",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "admin",
-				Permissions: []string{frontier.RoleOrgOwner},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.GrantAccess(pc, a)
-
-			assert.Nil(t, actualError)
-		})
-	})
-}
-
-func TestRevokeAccess(t *testing.T) {
-	t.Run("should return error if credentials is invalid", func(t *testing.T) {
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-
-		pc := &domain.ProviderConfig{
-			Credentials: "invalid-credentials",
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "test-type",
-					Roles: []*domain.Role{
-						{
-							ID:          "test-role",
-							Permissions: []interface{}{"test-permission-config"},
-						},
-					},
-				},
-			},
-		}
-		a := domain.Grant{
-			Resource: &domain.Resource{
-				Type: "test-type",
-			},
-			Role: "test-role",
-		}
-
-		actualError := p.RevokeAccess(pc, a)
-		assert.Error(t, actualError)
-	})
-
-	t.Run("should return error if resource type in unknown", func(t *testing.T) {
-		providerURN := "test-provider-urn"
-		client := mocks.NewClient(t)
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("", logger)
-		p.Clients = map[string]frontier.Client{
-			providerURN: client,
-		}
-
-		expectedError := errors.New("invalid resource type")
-		expectedUserEmail := "test@email.com"
-		expectedUser := &frontier.User{
-			ID:    "test_user_id",
-			Name:  "test_user",
-			Email: expectedUserEmail,
-		}
-
-		client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-
-		pc := &domain.ProviderConfig{
-			Credentials: frontier.Credentials{
-				Host:      "http://localhost/",
-				AuthEmail: "test_email",
-			},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "test-type",
-					Roles: []*domain.Role{
-						{
-							ID:          "test-role",
-							Permissions: []interface{}{"test-permission-config"},
-						},
-					},
-				},
-			},
-			URN: providerURN,
-		}
-		a := domain.Grant{
-			Resource: &domain.Resource{
-				Type: "test-type",
-			},
-			Role:      "test-role",
-			AccountID: expectedUserEmail,
-		}
-
-		actualError := p.RevokeAccess(pc, a)
-		assert.EqualError(t, actualError, expectedError.Error())
-	})
-
-	t.Run("given team resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in revoking team access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("RevokeTeamAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeTeam,
-						Roles: []*domain.Role{
-							{
-								ID:          "test-role",
-								Permissions: []interface{}{"test-permission-config"},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeTeam,
-					URN:  "team:team_id",
-					Name: "team_1",
-					Details: map[string]interface{}{
-						"id":     "team_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-						"metadata": frontier.Metadata{
-							Email:   "team_1@raystack.org",
-							Privacy: "public",
-							Slack:   "team_1_slack",
-						},
-					},
-				},
-				Role:        "test-role",
-				AccountID:   expectedUserEmail,
-				Permissions: []string{"test-permission-config"},
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if revoking team access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			client := mocks.NewClient(t)
-			expectedTeam := &frontier.Team{
-				Name:  "team_1",
-				ID:    "team_id",
-				OrgId: "456",
-				Metadata: frontier.Metadata{
-					Email:   "team_1@raystack.org",
-					Privacy: "public",
-					Slack:   "team_1_slack",
-				},
-				Admins: []string{"testAdmin@email.com"},
-			}
-
-			expectedRole := "admins"
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("RevokeTeamAccess", expectedTeam, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeTeam,
-						Roles: []*domain.Role{
-							{
-								ID:          "admin",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeTeam,
-					URN:  "team:team_id",
-					Name: "team_1",
-					Details: map[string]interface{}{
-						"id":     "team_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-						"metadata": frontier.Metadata{
-							Email:   "team_1@raystack.org",
-							Privacy: "public",
-							Slack:   "team_1_slack",
-						},
-					},
-				},
-				Role:        "admin",
-				Permissions: []string{expectedRole},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.Nil(t, actualError)
-			client.AssertExpectations(t)
-		})
-	})
-
-	t.Run("given project resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in revoking project access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-
-			client.On("RevokeProjectAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeProject,
-						Roles: []*domain.Role{
-							{
-								ID:          "test-role",
-								Permissions: []interface{}{"test-permission-config"},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeProject,
-					URN:  "project:project_id",
-					Name: "project_1",
-					Details: map[string]interface{}{
-						"id":     "project_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "test-role",
-				AccountID:   expectedUserEmail,
-				Permissions: []string{"test-permission-config"},
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if revoking access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			client := mocks.NewClient(t)
-			expectedProject := &frontier.Project{
-				Name:   "project_1",
-				ID:     "project_id",
-				OrgId:  "456",
-				Admins: []string{"testAdmin@email.com"},
-			}
-			expectedRole := "admins"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("RevokeProjectAccess", expectedProject, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeProject,
-						Roles: []*domain.Role{
-							{
-								ID:          "admin",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeProject,
-					URN:  "project:project_id",
-					Name: "project_1",
-					Details: map[string]interface{}{
-						"id":     "project_id",
-						"orgId":  "456",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "admin",
-				Permissions: []string{expectedRole},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.Nil(t, actualError)
-			client.AssertExpectations(t)
-		})
-	})
-
-	t.Run("given Organization resource", func(t *testing.T) {
-		t.Run("should return error if there is an error in revoking organization access", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			expectedError := errors.New("client error")
-			client := mocks.NewClient(t)
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("RevokeOrganizationAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeOrganization,
-						Roles: []*domain.Role{
-							{
-								ID:          "test-role",
-								Permissions: []interface{}{"test-permission-config"},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeOrganization,
-					URN:  "organization:org_id",
-					Name: "org_1",
-					Details: map[string]interface{}{
-						"id":     "org_id",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "test-role",
-				AccountID:   expectedUserEmail,
-				Permissions: []string{"test-permission-config"},
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.EqualError(t, actualError, expectedError.Error())
-		})
-
-		t.Run("should return nil error if revoking access is successful", func(t *testing.T) {
-			providerURN := "test-provider-urn"
-			client := mocks.NewClient(t)
-			expectedOrganization := &frontier.Organization{
-				Name:   "org_1",
-				ID:     "org_id",
-				Admins: []string{"testAdmin@email.com"},
-			}
-			expectedRole := "admins"
-			logger := log.NewLogrus(log.LogrusWithLevel("info"))
-			p := frontier.NewProvider("", logger)
-
-			p.Clients = map[string]frontier.Client{
-				providerURN: client,
-			}
-			expectedUserEmail := "test@email.com"
-			expectedUser := &frontier.User{
-				ID:    "test_user_id",
-				Name:  "test_user",
-				Email: expectedUserEmail,
-			}
-
-			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
-			client.On("RevokeOrganizationAccess", expectedOrganization, expectedUser.ID, expectedRole).Return(nil).Once()
-
-			pc := &domain.ProviderConfig{
-				Credentials: frontier.Credentials{
-					Host:      "localhost",
-					AuthEmail: "test_email",
-				},
-				Resources: []*domain.ResourceConfig{
-					{
-						Type: frontier.ResourceTypeOrganization,
-						Roles: []*domain.Role{
-							{
-								ID:          "admin",
-								Permissions: []interface{}{expectedRole},
-							},
-						},
-					},
-				},
-				URN: providerURN,
-			}
-			a := domain.Grant{
-				Resource: &domain.Resource{
-					Type: frontier.ResourceTypeOrganization,
-					URN:  "organization:org_id",
-					Name: "org_1",
-					Details: map[string]interface{}{
-						"id":     "org_id",
-						"admins": []interface{}{"testAdmin@email.com"},
-					},
-				},
-				Role:        "admin",
-				Permissions: []string{expectedRole},
-				AccountID:   expectedUserEmail,
-				ResourceID:  "999",
-				ID:          "999",
-			}
-
-			actualError := p.RevokeAccess(pc, a)
-
-			assert.Nil(t, actualError)
-			client.AssertExpectations(t)
-		})
-	})
-}
-
-func TestGetAccountTypes(t *testing.T) {
-	expectedAccountType := []string{"user"}
-	logger := log.NewLogrus(log.LogrusWithLevel("info"))
-	p := frontier.NewProvider("", logger)
-
-	actualAccountType := p.GetAccountTypes()
-
-	assert.Equal(t, expectedAccountType, actualAccountType)
-}
-
-func TestGetRoles(t *testing.T) {
-	t.Run("should return error if resource type is invalid", func(t *testing.T) {
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("shield", logger)
-		validConfig := &domain.ProviderConfig{
-			Type:                "shield",
-			URN:                 "test-URN",
-			AllowedAccountTypes: []string{"user"},
-			Credentials:         map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "team",
-					Policy: &domain.PolicyConfig{
-						ID:      "test-policy-1",
-						Version: 1,
-					},
-				},
-				{
-					Type: "project",
-					Policy: &domain.PolicyConfig{
-						ID:      "test-policy-2",
-						Version: 1,
-					},
-				},
-				{
-					Type: "organization",
-					Policy: &domain.PolicyConfig{
-						ID:      "test-policy-3",
-						Version: 1,
-					},
-				},
-			},
-		}
-
-		actualRoles, actualError := p.GetRoles(validConfig, "invalid_resource_type")
-
-		assert.Nil(t, actualRoles)
-		assert.ErrorIs(t, actualError, provider.ErrInvalidResourceType)
-	})
-
-	t.Run("should return roles specified in the provider config", func(t *testing.T) {
-		logger := log.NewLogrus(log.LogrusWithLevel("info"))
-		p := frontier.NewProvider("shield", logger)
-
-		expectedRoles := []*domain.Role{
-			{
-				ID:   "test-role",
-				Name: "test_role_name",
-			},
-		}
-
-		validConfig := &domain.ProviderConfig{
-			Type:                "shield",
-			URN:                 "test-URN",
-			AllowedAccountTypes: []string{"user"},
-			Credentials:         map[string]interface{}{},
-			Resources: []*domain.ResourceConfig{
-				{
-					Type: "team",
-					Policy: &domain.PolicyConfig{
-						ID:      "test-policy-1",
-						Version: 1,
-					},
-					Roles: expectedRoles,
-				},
-			},
-		}
-
-		actualRoles, actualError := p.GetRoles(validConfig, "team")
-
-		assert.NoError(t, actualError)
-		assert.Equal(t, expectedRoles, actualRoles)
-	})
-}
+// import (
+// 	"errors"
+// 	"testing"
+
+// 	"github.com/raystack/salt/log"
+
+// 	"github.com/raystack/guardian/core/provider"
+// 	"github.com/raystack/guardian/domain"
+// 	"github.com/raystack/guardian/mocks"
+// 	"github.com/raystack/guardian/plugins/providers/frontier"
+// 	"github.com/stretchr/testify/assert"
+// 	"github.com/stretchr/testify/mock"
+// )
+
+// func TestGetType(t *testing.T) {
+// 	t.Run("should return provider type name", func(t *testing.T) {
+// 		expectedTypeName := domain.ProviderTypeFrontier
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider(expectedTypeName, logger)
+
+// 		actualTypeName := p.GetType()
+
+// 		assert.Equal(t, expectedTypeName, actualTypeName)
+// 	})
+// }
+
+// func TestCreateConfig(t *testing.T) {
+// 	t.Run("should return error if there resource config is invalid", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		testcases := []struct {
+// 			pc *domain.ProviderConfig
+// 		}{
+// 			{
+// 				pc: &domain.ProviderConfig{
+// 					Credentials: frontier.Credentials{
+// 						Host:      "localhost",
+// 						AuthEmail: "test-email",
+// 					},
+// 					Resources: []*domain.ResourceConfig{
+// 						{
+// 							Type: "invalid resource type",
+// 						},
+// 					},
+// 				},
+// 			},
+// 			{
+// 				pc: &domain.ProviderConfig{
+// 					Credentials: frontier.Credentials{
+// 						Host:      "localhost",
+// 						AuthEmail: "test-email",
+// 					},
+// 					Resources: []*domain.ResourceConfig{
+// 						{
+// 							Type: frontier.ResourceTypeGroup,
+// 							Roles: []*domain.Role{
+// 								{
+// 									ID:          "member",
+// 									Permissions: []interface{}{"wrong permissions"},
+// 								},
+// 							},
+// 						},
+// 					},
+// 				},
+// 			},
+// 		}
+
+// 		for _, tc := range testcases {
+// 			actualError := p.CreateConfig(tc.pc)
+// 			assert.Error(t, actualError)
+// 		}
+// 	})
+
+// 	t.Run("should not return error if parse and valid of Credentials are correct", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		testcases := []struct {
+// 			pc            *domain.ProviderConfig
+// 			expectedError error
+// 		}{
+// 			{
+// 				pc: &domain.ProviderConfig{
+// 					Credentials: frontier.Credentials{
+// 						Host:       "localhost",
+// 						AuthEmail:  "test-email",
+// 						AuthHeader: "X-Frontier-Email",
+// 					},
+// 					Resources: []*domain.ResourceConfig{
+// 						{
+// 							Type: frontier.ResourceTypeGroup,
+// 							Roles: []*domain.Role{
+// 								{
+// 									ID: "member",
+// 									Permissions: []interface{}{
+// 										frontier.RoleGroupMember,
+// 									},
+// 								},
+// 								{
+// 									ID: "admin",
+// 									Permissions: []interface{}{
+// 										frontier.RoleGroupOwner,
+// 									},
+// 								},
+// 							},
+// 						},
+// 					},
+// 					URN: providerURN,
+// 				},
+// 				expectedError: nil,
+// 			},
+// 			{
+// 				pc: &domain.ProviderConfig{
+// 					Credentials: frontier.Credentials{
+// 						Host:       "localhost",
+// 						AuthEmail:  "test-email",
+// 						AuthHeader: "X-Frontier-Email",
+// 					},
+// 					Resources: []*domain.ResourceConfig{
+// 						{
+// 							Type: frontier.ResourceTypeProject,
+// 							Roles: []*domain.Role{
+// 								{
+// 									ID: "admin",
+// 									Permissions: []interface{}{
+// 										frontier.RoleProjectOwner,
+// 									},
+// 								},
+// 							},
+// 						},
+// 					},
+// 					URN: providerURN,
+// 				},
+// 				expectedError: nil,
+// 			},
+// 			{
+// 				pc: &domain.ProviderConfig{
+// 					Credentials: frontier.Credentials{
+// 						Host:       "localhost",
+// 						AuthEmail:  "test-email",
+// 						AuthHeader: "X-Frontier-Email",
+// 					},
+// 					Resources: []*domain.ResourceConfig{
+// 						{
+// 							Type: frontier.ResourceTypeOrganization,
+// 							Roles: []*domain.Role{
+// 								{
+// 									ID:          "admin",
+// 									Permissions: []interface{}{frontier.RoleOrgOwner},
+// 								},
+// 							},
+// 						},
+// 					},
+// 					URN: providerURN,
+// 				},
+// 				expectedError: nil,
+// 			},
+// 		}
+
+// 		for _, tc := range testcases {
+// 			actualError := p.CreateConfig(tc.pc)
+// 			assert.Equal(t, tc.expectedError, actualError)
+// 		}
+// 	})
+// }
+
+// func TestGetResources(t *testing.T) {
+// 	t.Run("should return error if credentials is invalid", func(t *testing.T) {
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+
+// 		pc := &domain.ProviderConfig{
+// 			Credentials: "invalid-creds",
+// 		}
+
+// 		actualResources, actualError := p.GetResources(pc)
+
+// 		assert.Nil(t, actualResources)
+// 		assert.Error(t, actualError)
+// 	})
+
+// 	t.Run("should return error if got any on getting team resources", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		pc := &domain.ProviderConfig{
+// 			URN:         providerURN,
+// 			Credentials: map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: frontier.ResourceTypeOrganization,
+// 				},
+// 				{
+// 					Type: frontier.ResourceTypeGroup,
+// 				},
+// 			},
+// 		}
+// 		expectedError := errors.New("client error")
+// 		expectedOrganizations := []*frontier.Organization{
+// 			{
+// 				ID:     "org_id",
+// 				Name:   "org_1",
+// 				Admins: []string{"testOrganizationAdmin@gmail.com"},
+// 			},
+// 		}
+
+// 		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
+// 		client.On("GetTeams", "org_id").Return(nil, expectedError).Once()
+
+// 		actualResources, actualError := p.GetResources(pc)
+
+// 		assert.Nil(t, actualResources)
+// 		assert.EqualError(t, actualError, expectedError.Error())
+// 	})
+
+// 	t.Run("should return error if got any on getting project resources", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		pc := &domain.ProviderConfig{
+// 			URN:         providerURN,
+// 			Credentials: map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: frontier.ResourceTypeOrganization,
+// 				},
+// 				{
+// 					Type: frontier.ResourceTypeProject,
+// 				},
+// 			},
+// 		}
+
+// 		expectedOrganizations := []*frontier.Organization{
+// 			{
+// 				ID:     "org_id",
+// 				Name:   "org_1",
+// 				Admins: []string{"testOrganizationAdmin@gmail.com"},
+// 			},
+// 		}
+
+// 		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
+
+// 		expectedError := errors.New("client error")
+// 		client.On("GetProjects", "org_id").Return(nil, expectedError).Once()
+
+// 		actualResources, actualError := p.GetResources(pc)
+
+// 		assert.Nil(t, actualResources)
+// 		assert.EqualError(t, actualError, expectedError.Error())
+// 	})
+
+// 	t.Run("should return error if got any on getting organization resources", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		pc := &domain.ProviderConfig{
+// 			URN:         providerURN,
+// 			Credentials: map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: frontier.ResourceTypeOrganization,
+// 				},
+// 			},
+// 		}
+// 		expectedError := errors.New("client error")
+// 		client.On("GetOrganizations").Return(nil, expectedError).Once()
+
+// 		actualResources, actualError := p.GetResources(pc)
+
+// 		assert.Nil(t, actualResources)
+// 		assert.EqualError(t, actualError, expectedError.Error())
+// 	})
+
+// 	t.Run("should return list of resources and nil error on success", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		pc := &domain.ProviderConfig{
+// 			URN:         providerURN,
+// 			Credentials: map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: frontier.ResourceTypeGroup,
+// 				},
+// 				{
+// 					Type: frontier.ResourceTypeProject,
+// 				},
+// 				{
+// 					Type: frontier.ResourceTypeOrganization,
+// 				},
+// 			},
+// 		}
+
+// 		expectedOrganizations := []*frontier.Organization{
+// 			{
+// 				ID:     "org_id",
+// 				Name:   "org_1",
+// 				Admins: []string{"testOrganizationAdmin@gmail.com"},
+// 			},
+// 		}
+
+// 		client.On("GetOrganizations").Return(expectedOrganizations, nil).Once()
+
+// 		expectedTeams := []*frontier.Group{
+// 			{
+// 				ID:    "team_id",
+// 				Name:  "team_1",
+// 				OrgId: "org_id",
+// 				Metadata: frontier.Metadata{
+// 					Email:   "team_1@raystack.org",
+// 					Privacy: "public",
+// 					Slack:   "team_1_slack",
+// 				},
+// 				Admins: []string{"testTeamAdmin@gmail.com"},
+// 			},
+// 		}
+// 		client.On("GetTeams", "org_id").Return(expectedTeams, nil).Once()
+
+// 		expectedProjects := []*frontier.Project{
+// 			{
+// 				ID:     "project_id",
+// 				Name:   "project_1",
+// 				OrgId:  "org_id",
+// 				Admins: []string{"testProjectAdmin@gmail.com"},
+// 			},
+// 		}
+// 		client.On("GetProjects", "org_id").Return(expectedProjects, nil).Once()
+
+// 		expectedResources := []*domain.Resource{
+// 			{
+// 				Type:        frontier.ResourceTypeOrganization,
+// 				URN:         "organization:org_id",
+// 				ProviderURN: providerURN,
+// 				Name:        "org_1",
+// 				Details: map[string]interface{}{
+// 					"id":     "org_id",
+// 					"admins": []string{"testOrganizationAdmin@gmail.com"},
+// 				},
+// 			},
+// 			{
+// 				Type:        frontier.ResourceTypeProject,
+// 				URN:         "project:project_id",
+// 				ProviderURN: providerURN,
+// 				Name:        "project_1",
+// 				Details: map[string]interface{}{
+// 					"id":     "project_id",
+// 					"orgId":  "org_id",
+// 					"admins": []string{"testProjectAdmin@gmail.com"},
+// 				},
+// 			},
+// 			{
+// 				Type:        frontier.ResourceTypeGroup,
+// 				URN:         "team:team_id",
+// 				ProviderURN: providerURN,
+// 				Name:        "team_1",
+// 				Details: map[string]interface{}{
+// 					"id":     "team_id",
+// 					"orgId":  "org_id",
+// 					"admins": []string{"testTeamAdmin@gmail.com"},
+// 					"metadata": frontier.Metadata{
+// 						Email:   "team_1@raystack.org",
+// 						Privacy: "public",
+// 						Slack:   "team_1_slack",
+// 					},
+// 				},
+// 			},
+// 		}
+
+// 		actualResources, actualError := p.GetResources(pc)
+
+// 		assert.Equal(t, expectedResources, actualResources)
+// 		assert.Nil(t, actualError)
+// 	})
+// }
+
+// func TestGrantAccess(t *testing.T) {
+// 	t.Run("should return error if credentials is invalid", func(t *testing.T) {
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+
+// 		pc := &domain.ProviderConfig{
+// 			Credentials: "invalid-credentials",
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "test-type",
+// 					Roles: []*domain.Role{
+// 						{
+// 							ID:          "test-role",
+// 							Permissions: []interface{}{"test-permission-config"},
+// 						},
+// 					},
+// 				},
+// 			},
+// 		}
+// 		a := domain.Grant{
+// 			Resource: &domain.Resource{
+// 				Type: "test-type",
+// 			},
+// 			Role: "test-role",
+// 		}
+
+// 		actualError := p.GrantAccess(pc, a)
+// 		assert.Error(t, actualError)
+// 	})
+
+// 	t.Run("should return error if resource type in unknown", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		expectedError := errors.New("invalid resource type")
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		expectedUserEmail := "test@email.com"
+// 		expectedUser := &frontier.User{
+// 			ID:    "test_user_id",
+// 			Name:  "test_user",
+// 			Email: expectedUserEmail,
+// 		}
+
+// 		client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+
+// 		pc := &domain.ProviderConfig{
+// 			Credentials: frontier.Credentials{
+// 				Host:       "http://localhost/",
+// 				AuthHeader: "X-Frontier-Email",
+// 				AuthEmail:  "test-email",
+// 			},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "test-type",
+// 					Roles: []*domain.Role{
+// 						{
+// 							ID:          "test-role",
+// 							Permissions: []interface{}{"test-permission-config"},
+// 						},
+// 					},
+// 				},
+// 			},
+// 			URN: providerURN,
+// 		}
+
+// 		a := domain.Grant{
+// 			Resource: &domain.Resource{
+// 				Type: "test-type",
+// 			},
+// 			Role:      "test-role",
+// 			AccountID: expectedUserEmail,
+// 		}
+
+// 		actualError := p.GrantAccess(pc, a)
+
+// 		assert.EqualError(t, actualError, expectedError.Error())
+// 	})
+
+// 	t.Run("given team resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in granting team access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantTeamAccess", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:       "localhost",
+// 					AuthHeader: "X-Frontier-Email",
+// 					AuthEmail:  "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeGroup,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "test-role",
+// 								Permissions: []interface{}{"test-permission-config"},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeGroup,
+// 					URN:  "team:team_id",
+// 					Name: "team_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "team_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 						"metadata": frontier.Metadata{
+// 							Email:   "team_1@raystack.org",
+// 							Privacy: "public",
+// 							Slack:   "team_1_slack",
+// 						},
+// 					},
+// 				},
+// 				Role:      "test-role",
+// 				AccountID: expectedUserEmail,
+// 				Permissions: []string{
+// 					frontier.RoleGroupMember,
+// 				},
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			client := mocks.NewClient(t)
+// 			expectedTeam := &frontier.Group{
+// 				Name:   "team_1",
+// 				ID:     "team_id",
+// 				OrgId:  "456",
+// 				Admins: []string{"testAdmin@email.com"},
+// 				Metadata: frontier.Metadata{
+// 					Email:   "team_1@raystack.org",
+// 					Privacy: "public",
+// 					Slack:   "team_1_slack",
+// 				},
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			expectedRole := frontier.RoleGroupMember
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantTeamAccess", expectedTeam, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:       "localhost",
+// 					AuthHeader: "X-Frontier-Email",
+// 					AuthEmail:  "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeGroup,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "member",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeGroup,
+// 					URN:  "team:team_id",
+// 					Name: "team_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "team_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 						"metadata": frontier.Metadata{
+// 							Email:   "team_1@raystack.org",
+// 							Privacy: "public",
+// 							Slack:   "team_1_slack",
+// 						},
+// 					},
+// 				},
+// 				Role:        "member",
+// 				Permissions: []string{frontier.RoleGroupMember},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 		})
+// 	})
+
+// 	t.Run("given project resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in granting project access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantProjectAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:       "localhost",
+// 					AuthHeader: "X-Frontier-Email",
+// 					AuthEmail:  "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeProject,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "test-role",
+// 								Permissions: []interface{}{"test-permission-config"},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeProject,
+// 					URN:  "project:project_id",
+// 					Name: "project_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "project_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "test-role",
+// 				AccountID:   expectedUserEmail,
+// 				Permissions: []string{"test-permission-config"},
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			client := mocks.NewClient(t)
+// 			expectedProject := &frontier.Project{
+// 				Name:   "project_1",
+// 				ID:     "project_id",
+// 				OrgId:  "456",
+// 				Admins: []string{},
+// 			}
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			expectedRole := frontier.RoleProjectOwner
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantProjectAccess", expectedProject, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:       "localhost",
+// 					AuthHeader: "X-Frontier-Email",
+// 					AuthEmail:  "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeProject,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "admin",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeProject,
+// 					URN:  "project:project_id",
+// 					Name: "project_1",
+// 					Details: map[string]interface{}{
+// 						"id":                  "project_id",
+// 						"orgId":               "456",
+// 						frontier.RoleOrgOwner: []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "admin",
+// 				Permissions: []string{frontier.RoleProjectOwner},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 		})
+// 	})
+
+// 	t.Run("given organization resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in granting organization access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantOrganizationAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeOrganization,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID: "test-role",
+// 								Permissions: []interface{}{
+// 									frontier.RoleOrgOwner,
+// 								},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeOrganization,
+// 					URN:  "organization:org_id",
+// 					Name: "org_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "org_id",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "test-role",
+// 				Permissions: []string{frontier.RoleOrgOwner},
+// 				AccountID:   expectedUserEmail,
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if granting access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			client := mocks.NewClient(t)
+// 			expectedOrganization := &frontier.Organization{
+// 				Name:   "org_1",
+// 				ID:     "org_id",
+// 				Admins: []string{"testAdmin@email.com"},
+// 			}
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			expectedRole := frontier.RoleOrgOwner
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("GrantOrganizationAccess", expectedOrganization, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeOrganization,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "admin",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeOrganization,
+// 					URN:  "organization:org_id",
+// 					Name: "org_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "org_id",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "admin",
+// 				Permissions: []string{frontier.RoleOrgOwner},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.GrantAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 		})
+// 	})
+// }
+
+// func TestRevokeAccess(t *testing.T) {
+// 	t.Run("should return error if credentials is invalid", func(t *testing.T) {
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+
+// 		pc := &domain.ProviderConfig{
+// 			Credentials: "invalid-credentials",
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "test-type",
+// 					Roles: []*domain.Role{
+// 						{
+// 							ID:          "test-role",
+// 							Permissions: []interface{}{"test-permission-config"},
+// 						},
+// 					},
+// 				},
+// 			},
+// 		}
+// 		a := domain.Grant{
+// 			Resource: &domain.Resource{
+// 				Type: "test-type",
+// 			},
+// 			Role: "test-role",
+// 		}
+
+// 		actualError := p.RevokeAccess(pc, a)
+// 		assert.Error(t, actualError)
+// 	})
+
+// 	t.Run("should return error if resource type in unknown", func(t *testing.T) {
+// 		providerURN := "test-provider-urn"
+// 		client := mocks.NewClient(t)
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("", logger)
+// 		p.Clients = map[string]frontier.Client{
+// 			providerURN: client,
+// 		}
+
+// 		expectedError := errors.New("invalid resource type")
+// 		expectedUserEmail := "test@email.com"
+// 		expectedUser := &frontier.User{
+// 			ID:    "test_user_id",
+// 			Name:  "test_user",
+// 			Email: expectedUserEmail,
+// 		}
+
+// 		client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+
+// 		pc := &domain.ProviderConfig{
+// 			Credentials: frontier.Credentials{
+// 				Host:      "http://localhost/",
+// 				AuthEmail: "test_email",
+// 			},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "test-type",
+// 					Roles: []*domain.Role{
+// 						{
+// 							ID:          "test-role",
+// 							Permissions: []interface{}{"test-permission-config"},
+// 						},
+// 					},
+// 				},
+// 			},
+// 			URN: providerURN,
+// 		}
+// 		a := domain.Grant{
+// 			Resource: &domain.Resource{
+// 				Type: "test-type",
+// 			},
+// 			Role:      "test-role",
+// 			AccountID: expectedUserEmail,
+// 		}
+
+// 		actualError := p.RevokeAccess(pc, a)
+// 		assert.EqualError(t, actualError, expectedError.Error())
+// 	})
+
+// 	t.Run("given team resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in revoking team access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("RevokeTeamAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeGroup,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "test-role",
+// 								Permissions: []interface{}{"test-permission-config"},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeGroup,
+// 					URN:  "team:team_id",
+// 					Name: "team_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "team_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 						"metadata": frontier.Metadata{
+// 							Email:   "team_1@raystack.org",
+// 							Privacy: "public",
+// 							Slack:   "team_1_slack",
+// 						},
+// 					},
+// 				},
+// 				Role:        "test-role",
+// 				AccountID:   expectedUserEmail,
+// 				Permissions: []string{"test-permission-config"},
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if revoking team access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			client := mocks.NewClient(t)
+// 			expectedTeam := &frontier.Group{
+// 				Name:  "team_1",
+// 				ID:    "team_id",
+// 				OrgId: "456",
+// 				Metadata: frontier.Metadata{
+// 					Email:   "team_1@raystack.org",
+// 					Privacy: "public",
+// 					Slack:   "team_1_slack",
+// 				},
+// 				Admins: []string{"testAdmin@email.com"},
+// 			}
+
+// 			expectedRole := "admins"
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("RevokeTeamAccess", expectedTeam, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeGroup,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "admin",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeGroup,
+// 					URN:  "team:team_id",
+// 					Name: "team_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "team_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 						"metadata": frontier.Metadata{
+// 							Email:   "team_1@raystack.org",
+// 							Privacy: "public",
+// 							Slack:   "team_1_slack",
+// 						},
+// 					},
+// 				},
+// 				Role:        "admin",
+// 				Permissions: []string{expectedRole},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 			client.AssertExpectations(t)
+// 		})
+// 	})
+
+// 	t.Run("given project resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in revoking project access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+
+// 			client.On("RevokeProjectAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeProject,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "test-role",
+// 								Permissions: []interface{}{"test-permission-config"},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeProject,
+// 					URN:  "project:project_id",
+// 					Name: "project_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "project_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "test-role",
+// 				AccountID:   expectedUserEmail,
+// 				Permissions: []string{"test-permission-config"},
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if revoking access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			client := mocks.NewClient(t)
+// 			expectedProject := &frontier.Project{
+// 				Name:   "project_1",
+// 				ID:     "project_id",
+// 				OrgId:  "456",
+// 				Admins: []string{"testAdmin@email.com"},
+// 			}
+// 			expectedRole := "admins"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("RevokeProjectAccess", expectedProject, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeProject,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "admin",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeProject,
+// 					URN:  "project:project_id",
+// 					Name: "project_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "project_id",
+// 						"orgId":  "456",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "admin",
+// 				Permissions: []string{expectedRole},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 			client.AssertExpectations(t)
+// 		})
+// 	})
+
+// 	t.Run("given Organization resource", func(t *testing.T) {
+// 		t.Run("should return error if there is an error in revoking organization access", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			expectedError := errors.New("client error")
+// 			client := mocks.NewClient(t)
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("RevokeOrganizationAccess", mock.Anything, mock.Anything, mock.Anything).Return(expectedError).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeOrganization,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "test-role",
+// 								Permissions: []interface{}{"test-permission-config"},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeOrganization,
+// 					URN:  "organization:org_id",
+// 					Name: "org_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "org_id",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "test-role",
+// 				AccountID:   expectedUserEmail,
+// 				Permissions: []string{"test-permission-config"},
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.EqualError(t, actualError, expectedError.Error())
+// 		})
+
+// 		t.Run("should return nil error if revoking access is successful", func(t *testing.T) {
+// 			providerURN := "test-provider-urn"
+// 			client := mocks.NewClient(t)
+// 			expectedOrganization := &frontier.Organization{
+// 				Name:   "org_1",
+// 				ID:     "org_id",
+// 				Admins: []string{"testAdmin@email.com"},
+// 			}
+// 			expectedRole := "admins"
+// 			logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 			p := frontier.NewProvider("", logger)
+
+// 			p.Clients = map[string]frontier.Client{
+// 				providerURN: client,
+// 			}
+// 			expectedUserEmail := "test@email.com"
+// 			expectedUser := &frontier.User{
+// 				ID:    "test_user_id",
+// 				Name:  "test_user",
+// 				Email: expectedUserEmail,
+// 			}
+
+// 			client.On("GetSelfUser", expectedUserEmail).Return(expectedUser, nil).Once()
+// 			client.On("RevokeOrganizationAccess", expectedOrganization, expectedUser.ID, expectedRole).Return(nil).Once()
+
+// 			pc := &domain.ProviderConfig{
+// 				Credentials: frontier.Credentials{
+// 					Host:      "localhost",
+// 					AuthEmail: "test_email",
+// 				},
+// 				Resources: []*domain.ResourceConfig{
+// 					{
+// 						Type: frontier.ResourceTypeOrganization,
+// 						Roles: []*domain.Role{
+// 							{
+// 								ID:          "admin",
+// 								Permissions: []interface{}{expectedRole},
+// 							},
+// 						},
+// 					},
+// 				},
+// 				URN: providerURN,
+// 			}
+// 			a := domain.Grant{
+// 				Resource: &domain.Resource{
+// 					Type: frontier.ResourceTypeOrganization,
+// 					URN:  "organization:org_id",
+// 					Name: "org_1",
+// 					Details: map[string]interface{}{
+// 						"id":     "org_id",
+// 						"admins": []interface{}{"testAdmin@email.com"},
+// 					},
+// 				},
+// 				Role:        "admin",
+// 				Permissions: []string{expectedRole},
+// 				AccountID:   expectedUserEmail,
+// 				ResourceID:  "999",
+// 				ID:          "999",
+// 			}
+
+// 			actualError := p.RevokeAccess(pc, a)
+
+// 			assert.Nil(t, actualError)
+// 			client.AssertExpectations(t)
+// 		})
+// 	})
+// }
+
+// func TestGetAccountTypes(t *testing.T) {
+// 	expectedAccountType := []string{"user"}
+// 	logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 	p := frontier.NewProvider("", logger)
+
+// 	actualAccountType := p.GetAccountTypes()
+
+// 	assert.Equal(t, expectedAccountType, actualAccountType)
+// }
+
+// func TestGetRoles(t *testing.T) {
+// 	t.Run("should return error if resource type is invalid", func(t *testing.T) {
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("shield", logger)
+// 		validConfig := &domain.ProviderConfig{
+// 			Type:                "shield",
+// 			URN:                 "test-URN",
+// 			AllowedAccountTypes: []string{"user"},
+// 			Credentials:         map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "team",
+// 					Policy: &domain.PolicyConfig{
+// 						ID:      "test-policy-1",
+// 						Version: 1,
+// 					},
+// 				},
+// 				{
+// 					Type: "project",
+// 					Policy: &domain.PolicyConfig{
+// 						ID:      "test-policy-2",
+// 						Version: 1,
+// 					},
+// 				},
+// 				{
+// 					Type: "organization",
+// 					Policy: &domain.PolicyConfig{
+// 						ID:      "test-policy-3",
+// 						Version: 1,
+// 					},
+// 				},
+// 			},
+// 		}
+
+// 		actualRoles, actualError := p.GetRoles(validConfig, "invalid_resource_type")
+
+// 		assert.Nil(t, actualRoles)
+// 		assert.ErrorIs(t, actualError, provider.ErrInvalidResourceType)
+// 	})
+
+// 	t.Run("should return roles specified in the provider config", func(t *testing.T) {
+// 		logger := log.NewLogrus(log.LogrusWithLevel("info"))
+// 		p := frontier.NewProvider("shield", logger)
+
+// 		expectedRoles := []*domain.Role{
+// 			{
+// 				ID:   "test-role",
+// 				Name: "test_role_name",
+// 			},
+// 		}
+
+// 		validConfig := &domain.ProviderConfig{
+// 			Type:                "shield",
+// 			URN:                 "test-URN",
+// 			AllowedAccountTypes: []string{"user"},
+// 			Credentials:         map[string]interface{}{},
+// 			Resources: []*domain.ResourceConfig{
+// 				{
+// 					Type: "team",
+// 					Policy: &domain.PolicyConfig{
+// 						ID:      "test-policy-1",
+// 						Version: 1,
+// 					},
+// 					Roles: expectedRoles,
+// 				},
+// 			},
+// 		}
+
+// 		actualRoles, actualError := p.GetRoles(validConfig, "team")
+
+// 		assert.NoError(t, actualError)
+// 		assert.Equal(t, expectedRoles, actualRoles)
+// 	})
+// }
diff --git a/plugins/providers/frontier/resource.go b/plugins/providers/frontier/resource.go
index e2e0673a4..08434c9b8 100644
--- a/plugins/providers/frontier/resource.go
+++ b/plugins/providers/frontier/resource.go
@@ -7,7 +7,7 @@ import (
 )
 
 const (
-	ResourceTypeTeam         = "team"
+	ResourceTypeGroup        = "group"
 	ResourceTypeProject      = "project"
 	ResourceTypeOrganization = "organization"
 )
@@ -25,7 +25,7 @@ type User struct {
 	Email string `json:"email" mapstructure:"email"`
 }
 
-type Team struct {
+type Group struct {
 	ID       string   `json:"id" mapstructure:"id"`
 	Name     string   `json:"name" mapstructure:"name"`
 	Title    string   `json:"title" mapstructure:"title"`
@@ -49,8 +49,8 @@ type Organization struct {
 	Admins []string `json:"admins" mapstructure:"admins"`
 }
 
-func (t *Team) FromDomain(r *domain.Resource) error {
-	if r.Type != ResourceTypeTeam {
+func (t *Group) FromDomain(r *domain.Resource) error {
+	if r.Type != ResourceTypeGroup {
 		return ErrInvalidResourceType
 	}
 
@@ -83,11 +83,11 @@ func (t *Team) FromDomain(r *domain.Resource) error {
 	return nil
 }
 
-func (t *Team) ToDomain() *domain.Resource {
+func (t *Group) ToDomain() *domain.Resource {
 	return &domain.Resource{
-		Type: ResourceTypeTeam,
+		Type: ResourceTypeGroup,
 		Name: t.Name,
-		URN:  fmt.Sprintf("team:%v", t.ID),
+		URN:  fmt.Sprintf("group:%v", t.ID),
 		Details: map[string]interface{}{
 			"id":       t.ID,
 			"metadata": t.Metadata,