teams_api.go

// Code generated by mockery. DO NOT EDIT.

package mockadmin

import (
	context "context"

	admin "go.mongodb.org/atlas-sdk/v20231115008/admin"

	http "net/http"

	mock "github.com/stretchr/testify/mock"
)

// TeamsApi is an autogenerated mock type for the TeamsApi type
type TeamsApi struct {
	mock.Mock
}

type TeamsApi_Expecter struct {
	mock *mock.Mock
}

func (_m *TeamsApi) EXPECT() *TeamsApi_Expecter {
	return &TeamsApi_Expecter{mock: &_m.Mock}
}

// AddAllTeamsToProject provides a mock function with given fields: ctx, groupId, teamRole
func (_m *TeamsApi) AddAllTeamsToProject(ctx context.Context, groupId string, teamRole *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest {
	ret := _m.Called(ctx, groupId, teamRole)

	if len(ret) == 0 {
		panic("no return value specified for AddAllTeamsToProject")
	}

	var r0 admin.AddAllTeamsToProjectApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest); ok {
		r0 = rf(ctx, groupId, teamRole)
	} else {
		r0 = ret.Get(0).(admin.AddAllTeamsToProjectApiRequest)
	}

	return r0
}

// TeamsApi_AddAllTeamsToProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProject'
type TeamsApi_AddAllTeamsToProject_Call struct {
	*mock.Call
}

// AddAllTeamsToProject is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - teamRole *[]admin.TeamRole
func (_e *TeamsApi_Expecter) AddAllTeamsToProject(ctx interface{}, groupId interface{}, teamRole interface{}) *TeamsApi_AddAllTeamsToProject_Call {
	return &TeamsApi_AddAllTeamsToProject_Call{Call: _e.mock.On("AddAllTeamsToProject", ctx, groupId, teamRole)}
}

func (_c *TeamsApi_AddAllTeamsToProject_Call) Run(run func(ctx context.Context, groupId string, teamRole *[]admin.TeamRole)) *TeamsApi_AddAllTeamsToProject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*[]admin.TeamRole))
	})
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProject_Call) Return(_a0 admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProject_Call) RunAndReturn(run func(context.Context, string, *[]admin.TeamRole) admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProject_Call {
	_c.Call.Return(run)
	return _c
}

// AddAllTeamsToProjectExecute provides a mock function with given fields: r
func (_m *TeamsApi) AddAllTeamsToProjectExecute(r admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for AddAllTeamsToProjectExecute")
	}

	var r0 *admin.PaginatedTeamRole
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.AddAllTeamsToProjectApiRequest) *admin.PaginatedTeamRole); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedTeamRole)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.AddAllTeamsToProjectApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.AddAllTeamsToProjectApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_AddAllTeamsToProjectExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProjectExecute'
type TeamsApi_AddAllTeamsToProjectExecute_Call struct {
	*mock.Call
}

// AddAllTeamsToProjectExecute is a helper method to define mock.On call
//   - r admin.AddAllTeamsToProjectApiRequest
func (_e *TeamsApi_Expecter) AddAllTeamsToProjectExecute(r interface{}) *TeamsApi_AddAllTeamsToProjectExecute_Call {
	return &TeamsApi_AddAllTeamsToProjectExecute_Call{Call: _e.mock.On("AddAllTeamsToProjectExecute", r)}
}

func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) Run(run func(r admin.AddAllTeamsToProjectApiRequest)) *TeamsApi_AddAllTeamsToProjectExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.AddAllTeamsToProjectApiRequest))
	})
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_AddAllTeamsToProjectExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProjectExecute_Call) RunAndReturn(run func(admin.AddAllTeamsToProjectApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_AddAllTeamsToProjectExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AddAllTeamsToProjectWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) AddAllTeamsToProjectWithParams(ctx context.Context, args *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for AddAllTeamsToProjectWithParams")
	}

	var r0 admin.AddAllTeamsToProjectApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.AddAllTeamsToProjectApiRequest)
	}

	return r0
}

// TeamsApi_AddAllTeamsToProjectWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAllTeamsToProjectWithParams'
type TeamsApi_AddAllTeamsToProjectWithParams_Call struct {
	*mock.Call
}

// AddAllTeamsToProjectWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.AddAllTeamsToProjectApiParams
func (_e *TeamsApi_Expecter) AddAllTeamsToProjectWithParams(ctx interface{}, args interface{}) *TeamsApi_AddAllTeamsToProjectWithParams_Call {
	return &TeamsApi_AddAllTeamsToProjectWithParams_Call{Call: _e.mock.On("AddAllTeamsToProjectWithParams", ctx, args)}
}

func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) Run(run func(ctx context.Context, args *admin.AddAllTeamsToProjectApiParams)) *TeamsApi_AddAllTeamsToProjectWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.AddAllTeamsToProjectApiParams))
	})
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) Return(_a0 admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProjectWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_AddAllTeamsToProjectWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddAllTeamsToProjectApiParams) admin.AddAllTeamsToProjectApiRequest) *TeamsApi_AddAllTeamsToProjectWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// AddTeamUser provides a mock function with given fields: ctx, orgId, teamId, addUserToTeam
func (_m *TeamsApi) AddTeamUser(ctx context.Context, orgId string, teamId string, addUserToTeam *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest {
	ret := _m.Called(ctx, orgId, teamId, addUserToTeam)

	if len(ret) == 0 {
		panic("no return value specified for AddTeamUser")
	}

	var r0 admin.AddTeamUserApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest); ok {
		r0 = rf(ctx, orgId, teamId, addUserToTeam)
	} else {
		r0 = ret.Get(0).(admin.AddTeamUserApiRequest)
	}

	return r0
}

// TeamsApi_AddTeamUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUser'
type TeamsApi_AddTeamUser_Call struct {
	*mock.Call
}

// AddTeamUser is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
//   - addUserToTeam *[]admin.AddUserToTeam
func (_e *TeamsApi_Expecter) AddTeamUser(ctx interface{}, orgId interface{}, teamId interface{}, addUserToTeam interface{}) *TeamsApi_AddTeamUser_Call {
	return &TeamsApi_AddTeamUser_Call{Call: _e.mock.On("AddTeamUser", ctx, orgId, teamId, addUserToTeam)}
}

func (_c *TeamsApi_AddTeamUser_Call) Run(run func(ctx context.Context, orgId string, teamId string, addUserToTeam *[]admin.AddUserToTeam)) *TeamsApi_AddTeamUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.AddUserToTeam))
	})
	return _c
}

func (_c *TeamsApi_AddTeamUser_Call) Return(_a0 admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_AddTeamUser_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.AddUserToTeam) admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUser_Call {
	_c.Call.Return(run)
	return _c
}

// AddTeamUserExecute provides a mock function with given fields: r
func (_m *TeamsApi) AddTeamUserExecute(r admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for AddTeamUserExecute")
	}

	var r0 *admin.PaginatedApiAppUser
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.AddTeamUserApiRequest) *admin.PaginatedApiAppUser); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedApiAppUser)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.AddTeamUserApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.AddTeamUserApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_AddTeamUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUserExecute'
type TeamsApi_AddTeamUserExecute_Call struct {
	*mock.Call
}

// AddTeamUserExecute is a helper method to define mock.On call
//   - r admin.AddTeamUserApiRequest
func (_e *TeamsApi_Expecter) AddTeamUserExecute(r interface{}) *TeamsApi_AddTeamUserExecute_Call {
	return &TeamsApi_AddTeamUserExecute_Call{Call: _e.mock.On("AddTeamUserExecute", r)}
}

func (_c *TeamsApi_AddTeamUserExecute_Call) Run(run func(r admin.AddTeamUserApiRequest)) *TeamsApi_AddTeamUserExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.AddTeamUserApiRequest))
	})
	return _c
}

func (_c *TeamsApi_AddTeamUserExecute_Call) Return(_a0 *admin.PaginatedApiAppUser, _a1 *http.Response, _a2 error) *TeamsApi_AddTeamUserExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_AddTeamUserExecute_Call) RunAndReturn(run func(admin.AddTeamUserApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)) *TeamsApi_AddTeamUserExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AddTeamUserWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) AddTeamUserWithParams(ctx context.Context, args *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for AddTeamUserWithParams")
	}

	var r0 admin.AddTeamUserApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.AddTeamUserApiRequest)
	}

	return r0
}

// TeamsApi_AddTeamUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeamUserWithParams'
type TeamsApi_AddTeamUserWithParams_Call struct {
	*mock.Call
}

// AddTeamUserWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.AddTeamUserApiParams
func (_e *TeamsApi_Expecter) AddTeamUserWithParams(ctx interface{}, args interface{}) *TeamsApi_AddTeamUserWithParams_Call {
	return &TeamsApi_AddTeamUserWithParams_Call{Call: _e.mock.On("AddTeamUserWithParams", ctx, args)}
}

func (_c *TeamsApi_AddTeamUserWithParams_Call) Run(run func(ctx context.Context, args *admin.AddTeamUserApiParams)) *TeamsApi_AddTeamUserWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.AddTeamUserApiParams))
	})
	return _c
}

func (_c *TeamsApi_AddTeamUserWithParams_Call) Return(_a0 admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUserWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_AddTeamUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddTeamUserApiParams) admin.AddTeamUserApiRequest) *TeamsApi_AddTeamUserWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTeam provides a mock function with given fields: ctx, orgId, team
func (_m *TeamsApi) CreateTeam(ctx context.Context, orgId string, team *admin.Team) admin.CreateTeamApiRequest {
	ret := _m.Called(ctx, orgId, team)

	if len(ret) == 0 {
		panic("no return value specified for CreateTeam")
	}

	var r0 admin.CreateTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.Team) admin.CreateTeamApiRequest); ok {
		r0 = rf(ctx, orgId, team)
	} else {
		r0 = ret.Get(0).(admin.CreateTeamApiRequest)
	}

	return r0
}

// TeamsApi_CreateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeam'
type TeamsApi_CreateTeam_Call struct {
	*mock.Call
}

// CreateTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - team *admin.Team
func (_e *TeamsApi_Expecter) CreateTeam(ctx interface{}, orgId interface{}, team interface{}) *TeamsApi_CreateTeam_Call {
	return &TeamsApi_CreateTeam_Call{Call: _e.mock.On("CreateTeam", ctx, orgId, team)}
}

func (_c *TeamsApi_CreateTeam_Call) Run(run func(ctx context.Context, orgId string, team *admin.Team)) *TeamsApi_CreateTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.Team))
	})
	return _c
}

func (_c *TeamsApi_CreateTeam_Call) Return(_a0 admin.CreateTeamApiRequest) *TeamsApi_CreateTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_CreateTeam_Call) RunAndReturn(run func(context.Context, string, *admin.Team) admin.CreateTeamApiRequest) *TeamsApi_CreateTeam_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTeamExecute provides a mock function with given fields: r
func (_m *TeamsApi) CreateTeamExecute(r admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreateTeamExecute")
	}

	var r0 *admin.Team
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreateTeamApiRequest) *admin.Team); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Team)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreateTeamApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreateTeamApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_CreateTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamExecute'
type TeamsApi_CreateTeamExecute_Call struct {
	*mock.Call
}

// CreateTeamExecute is a helper method to define mock.On call
//   - r admin.CreateTeamApiRequest
func (_e *TeamsApi_Expecter) CreateTeamExecute(r interface{}) *TeamsApi_CreateTeamExecute_Call {
	return &TeamsApi_CreateTeamExecute_Call{Call: _e.mock.On("CreateTeamExecute", r)}
}

func (_c *TeamsApi_CreateTeamExecute_Call) Run(run func(r admin.CreateTeamApiRequest)) *TeamsApi_CreateTeamExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreateTeamApiRequest))
	})
	return _c
}

func (_c *TeamsApi_CreateTeamExecute_Call) Return(_a0 *admin.Team, _a1 *http.Response, _a2 error) *TeamsApi_CreateTeamExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_CreateTeamExecute_Call) RunAndReturn(run func(admin.CreateTeamApiRequest) (*admin.Team, *http.Response, error)) *TeamsApi_CreateTeamExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTeamWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) CreateTeamWithParams(ctx context.Context, args *admin.CreateTeamApiParams) admin.CreateTeamApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for CreateTeamWithParams")
	}

	var r0 admin.CreateTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateTeamApiParams) admin.CreateTeamApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreateTeamApiRequest)
	}

	return r0
}

// TeamsApi_CreateTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamWithParams'
type TeamsApi_CreateTeamWithParams_Call struct {
	*mock.Call
}

// CreateTeamWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateTeamApiParams
func (_e *TeamsApi_Expecter) CreateTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_CreateTeamWithParams_Call {
	return &TeamsApi_CreateTeamWithParams_Call{Call: _e.mock.On("CreateTeamWithParams", ctx, args)}
}

func (_c *TeamsApi_CreateTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateTeamApiParams)) *TeamsApi_CreateTeamWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreateTeamApiParams))
	})
	return _c
}

func (_c *TeamsApi_CreateTeamWithParams_Call) Return(_a0 admin.CreateTeamApiRequest) *TeamsApi_CreateTeamWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_CreateTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateTeamApiParams) admin.CreateTeamApiRequest) *TeamsApi_CreateTeamWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTeam provides a mock function with given fields: ctx, orgId, teamId
func (_m *TeamsApi) DeleteTeam(ctx context.Context, orgId string, teamId string) admin.DeleteTeamApiRequest {
	ret := _m.Called(ctx, orgId, teamId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTeam")
	}

	var r0 admin.DeleteTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteTeamApiRequest); ok {
		r0 = rf(ctx, orgId, teamId)
	} else {
		r0 = ret.Get(0).(admin.DeleteTeamApiRequest)
	}

	return r0
}

// TeamsApi_DeleteTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeam'
type TeamsApi_DeleteTeam_Call struct {
	*mock.Call
}

// DeleteTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
func (_e *TeamsApi_Expecter) DeleteTeam(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_DeleteTeam_Call {
	return &TeamsApi_DeleteTeam_Call{Call: _e.mock.On("DeleteTeam", ctx, orgId, teamId)}
}

func (_c *TeamsApi_DeleteTeam_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_DeleteTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *TeamsApi_DeleteTeam_Call) Return(_a0 admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_DeleteTeam_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeam_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTeamExecute provides a mock function with given fields: r
func (_m *TeamsApi) DeleteTeamExecute(r admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTeamExecute")
	}

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteTeamApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DeleteTeamApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DeleteTeamApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_DeleteTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeamExecute'
type TeamsApi_DeleteTeamExecute_Call struct {
	*mock.Call
}

// DeleteTeamExecute is a helper method to define mock.On call
//   - r admin.DeleteTeamApiRequest
func (_e *TeamsApi_Expecter) DeleteTeamExecute(r interface{}) *TeamsApi_DeleteTeamExecute_Call {
	return &TeamsApi_DeleteTeamExecute_Call{Call: _e.mock.On("DeleteTeamExecute", r)}
}

func (_c *TeamsApi_DeleteTeamExecute_Call) Run(run func(r admin.DeleteTeamApiRequest)) *TeamsApi_DeleteTeamExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DeleteTeamApiRequest))
	})
	return _c
}

func (_c *TeamsApi_DeleteTeamExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *TeamsApi_DeleteTeamExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_DeleteTeamExecute_Call) RunAndReturn(run func(admin.DeleteTeamApiRequest) (map[string]interface{}, *http.Response, error)) *TeamsApi_DeleteTeamExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTeamWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) DeleteTeamWithParams(ctx context.Context, args *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for DeleteTeamWithParams")
	}

	var r0 admin.DeleteTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DeleteTeamApiRequest)
	}

	return r0
}

// TeamsApi_DeleteTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeamWithParams'
type TeamsApi_DeleteTeamWithParams_Call struct {
	*mock.Call
}

// DeleteTeamWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteTeamApiParams
func (_e *TeamsApi_Expecter) DeleteTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_DeleteTeamWithParams_Call {
	return &TeamsApi_DeleteTeamWithParams_Call{Call: _e.mock.On("DeleteTeamWithParams", ctx, args)}
}

func (_c *TeamsApi_DeleteTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteTeamApiParams)) *TeamsApi_DeleteTeamWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DeleteTeamApiParams))
	})
	return _c
}

func (_c *TeamsApi_DeleteTeamWithParams_Call) Return(_a0 admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeamWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_DeleteTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteTeamApiParams) admin.DeleteTeamApiRequest) *TeamsApi_DeleteTeamWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamById provides a mock function with given fields: ctx, orgId, teamId
func (_m *TeamsApi) GetTeamById(ctx context.Context, orgId string, teamId string) admin.GetTeamByIdApiRequest {
	ret := _m.Called(ctx, orgId, teamId)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamById")
	}

	var r0 admin.GetTeamByIdApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetTeamByIdApiRequest); ok {
		r0 = rf(ctx, orgId, teamId)
	} else {
		r0 = ret.Get(0).(admin.GetTeamByIdApiRequest)
	}

	return r0
}

// TeamsApi_GetTeamById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamById'
type TeamsApi_GetTeamById_Call struct {
	*mock.Call
}

// GetTeamById is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
func (_e *TeamsApi_Expecter) GetTeamById(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_GetTeamById_Call {
	return &TeamsApi_GetTeamById_Call{Call: _e.mock.On("GetTeamById", ctx, orgId, teamId)}
}

func (_c *TeamsApi_GetTeamById_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_GetTeamById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *TeamsApi_GetTeamById_Call) Return(_a0 admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamById_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_GetTeamById_Call) RunAndReturn(run func(context.Context, string, string) admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamById_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamByIdExecute provides a mock function with given fields: r
func (_m *TeamsApi) GetTeamByIdExecute(r admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamByIdExecute")
	}

	var r0 *admin.TeamResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetTeamByIdApiRequest) *admin.TeamResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TeamResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetTeamByIdApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetTeamByIdApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_GetTeamByIdExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByIdExecute'
type TeamsApi_GetTeamByIdExecute_Call struct {
	*mock.Call
}

// GetTeamByIdExecute is a helper method to define mock.On call
//   - r admin.GetTeamByIdApiRequest
func (_e *TeamsApi_Expecter) GetTeamByIdExecute(r interface{}) *TeamsApi_GetTeamByIdExecute_Call {
	return &TeamsApi_GetTeamByIdExecute_Call{Call: _e.mock.On("GetTeamByIdExecute", r)}
}

func (_c *TeamsApi_GetTeamByIdExecute_Call) Run(run func(r admin.GetTeamByIdApiRequest)) *TeamsApi_GetTeamByIdExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetTeamByIdApiRequest))
	})
	return _c
}

func (_c *TeamsApi_GetTeamByIdExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_GetTeamByIdExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_GetTeamByIdExecute_Call) RunAndReturn(run func(admin.GetTeamByIdApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_GetTeamByIdExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamByIdWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) GetTeamByIdWithParams(ctx context.Context, args *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamByIdWithParams")
	}

	var r0 admin.GetTeamByIdApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetTeamByIdApiRequest)
	}

	return r0
}

// TeamsApi_GetTeamByIdWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByIdWithParams'
type TeamsApi_GetTeamByIdWithParams_Call struct {
	*mock.Call
}

// GetTeamByIdWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetTeamByIdApiParams
func (_e *TeamsApi_Expecter) GetTeamByIdWithParams(ctx interface{}, args interface{}) *TeamsApi_GetTeamByIdWithParams_Call {
	return &TeamsApi_GetTeamByIdWithParams_Call{Call: _e.mock.On("GetTeamByIdWithParams", ctx, args)}
}

func (_c *TeamsApi_GetTeamByIdWithParams_Call) Run(run func(ctx context.Context, args *admin.GetTeamByIdApiParams)) *TeamsApi_GetTeamByIdWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetTeamByIdApiParams))
	})
	return _c
}

func (_c *TeamsApi_GetTeamByIdWithParams_Call) Return(_a0 admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamByIdWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_GetTeamByIdWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetTeamByIdApiParams) admin.GetTeamByIdApiRequest) *TeamsApi_GetTeamByIdWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamByName provides a mock function with given fields: ctx, orgId, teamName
func (_m *TeamsApi) GetTeamByName(ctx context.Context, orgId string, teamName string) admin.GetTeamByNameApiRequest {
	ret := _m.Called(ctx, orgId, teamName)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamByName")
	}

	var r0 admin.GetTeamByNameApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetTeamByNameApiRequest); ok {
		r0 = rf(ctx, orgId, teamName)
	} else {
		r0 = ret.Get(0).(admin.GetTeamByNameApiRequest)
	}

	return r0
}

// TeamsApi_GetTeamByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByName'
type TeamsApi_GetTeamByName_Call struct {
	*mock.Call
}

// GetTeamByName is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamName string
func (_e *TeamsApi_Expecter) GetTeamByName(ctx interface{}, orgId interface{}, teamName interface{}) *TeamsApi_GetTeamByName_Call {
	return &TeamsApi_GetTeamByName_Call{Call: _e.mock.On("GetTeamByName", ctx, orgId, teamName)}
}

func (_c *TeamsApi_GetTeamByName_Call) Run(run func(ctx context.Context, orgId string, teamName string)) *TeamsApi_GetTeamByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *TeamsApi_GetTeamByName_Call) Return(_a0 admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByName_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_GetTeamByName_Call) RunAndReturn(run func(context.Context, string, string) admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamByNameExecute provides a mock function with given fields: r
func (_m *TeamsApi) GetTeamByNameExecute(r admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamByNameExecute")
	}

	var r0 *admin.TeamResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetTeamByNameApiRequest) *admin.TeamResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TeamResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetTeamByNameApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetTeamByNameApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_GetTeamByNameExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByNameExecute'
type TeamsApi_GetTeamByNameExecute_Call struct {
	*mock.Call
}

// GetTeamByNameExecute is a helper method to define mock.On call
//   - r admin.GetTeamByNameApiRequest
func (_e *TeamsApi_Expecter) GetTeamByNameExecute(r interface{}) *TeamsApi_GetTeamByNameExecute_Call {
	return &TeamsApi_GetTeamByNameExecute_Call{Call: _e.mock.On("GetTeamByNameExecute", r)}
}

func (_c *TeamsApi_GetTeamByNameExecute_Call) Run(run func(r admin.GetTeamByNameApiRequest)) *TeamsApi_GetTeamByNameExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetTeamByNameApiRequest))
	})
	return _c
}

func (_c *TeamsApi_GetTeamByNameExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_GetTeamByNameExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_GetTeamByNameExecute_Call) RunAndReturn(run func(admin.GetTeamByNameApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_GetTeamByNameExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetTeamByNameWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) GetTeamByNameWithParams(ctx context.Context, args *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for GetTeamByNameWithParams")
	}

	var r0 admin.GetTeamByNameApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetTeamByNameApiRequest)
	}

	return r0
}

// TeamsApi_GetTeamByNameWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamByNameWithParams'
type TeamsApi_GetTeamByNameWithParams_Call struct {
	*mock.Call
}

// GetTeamByNameWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetTeamByNameApiParams
func (_e *TeamsApi_Expecter) GetTeamByNameWithParams(ctx interface{}, args interface{}) *TeamsApi_GetTeamByNameWithParams_Call {
	return &TeamsApi_GetTeamByNameWithParams_Call{Call: _e.mock.On("GetTeamByNameWithParams", ctx, args)}
}

func (_c *TeamsApi_GetTeamByNameWithParams_Call) Run(run func(ctx context.Context, args *admin.GetTeamByNameApiParams)) *TeamsApi_GetTeamByNameWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetTeamByNameApiParams))
	})
	return _c
}

func (_c *TeamsApi_GetTeamByNameWithParams_Call) Return(_a0 admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByNameWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_GetTeamByNameWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetTeamByNameApiParams) admin.GetTeamByNameApiRequest) *TeamsApi_GetTeamByNameWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListOrganizationTeams provides a mock function with given fields: ctx, orgId
func (_m *TeamsApi) ListOrganizationTeams(ctx context.Context, orgId string) admin.ListOrganizationTeamsApiRequest {
	ret := _m.Called(ctx, orgId)

	if len(ret) == 0 {
		panic("no return value specified for ListOrganizationTeams")
	}

	var r0 admin.ListOrganizationTeamsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListOrganizationTeamsApiRequest); ok {
		r0 = rf(ctx, orgId)
	} else {
		r0 = ret.Get(0).(admin.ListOrganizationTeamsApiRequest)
	}

	return r0
}

// TeamsApi_ListOrganizationTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeams'
type TeamsApi_ListOrganizationTeams_Call struct {
	*mock.Call
}

// ListOrganizationTeams is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
func (_e *TeamsApi_Expecter) ListOrganizationTeams(ctx interface{}, orgId interface{}) *TeamsApi_ListOrganizationTeams_Call {
	return &TeamsApi_ListOrganizationTeams_Call{Call: _e.mock.On("ListOrganizationTeams", ctx, orgId)}
}

func (_c *TeamsApi_ListOrganizationTeams_Call) Run(run func(ctx context.Context, orgId string)) *TeamsApi_ListOrganizationTeams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *TeamsApi_ListOrganizationTeams_Call) Return(_a0 admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListOrganizationTeams_Call) RunAndReturn(run func(context.Context, string) admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeams_Call {
	_c.Call.Return(run)
	return _c
}

// ListOrganizationTeamsExecute provides a mock function with given fields: r
func (_m *TeamsApi) ListOrganizationTeamsExecute(r admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListOrganizationTeamsExecute")
	}

	var r0 *admin.PaginatedTeam
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListOrganizationTeamsApiRequest) *admin.PaginatedTeam); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedTeam)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListOrganizationTeamsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListOrganizationTeamsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_ListOrganizationTeamsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeamsExecute'
type TeamsApi_ListOrganizationTeamsExecute_Call struct {
	*mock.Call
}

// ListOrganizationTeamsExecute is a helper method to define mock.On call
//   - r admin.ListOrganizationTeamsApiRequest
func (_e *TeamsApi_Expecter) ListOrganizationTeamsExecute(r interface{}) *TeamsApi_ListOrganizationTeamsExecute_Call {
	return &TeamsApi_ListOrganizationTeamsExecute_Call{Call: _e.mock.On("ListOrganizationTeamsExecute", r)}
}

func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) Run(run func(r admin.ListOrganizationTeamsApiRequest)) *TeamsApi_ListOrganizationTeamsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListOrganizationTeamsApiRequest))
	})
	return _c
}

func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) Return(_a0 *admin.PaginatedTeam, _a1 *http.Response, _a2 error) *TeamsApi_ListOrganizationTeamsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_ListOrganizationTeamsExecute_Call) RunAndReturn(run func(admin.ListOrganizationTeamsApiRequest) (*admin.PaginatedTeam, *http.Response, error)) *TeamsApi_ListOrganizationTeamsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListOrganizationTeamsWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) ListOrganizationTeamsWithParams(ctx context.Context, args *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListOrganizationTeamsWithParams")
	}

	var r0 admin.ListOrganizationTeamsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListOrganizationTeamsApiRequest)
	}

	return r0
}

// TeamsApi_ListOrganizationTeamsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOrganizationTeamsWithParams'
type TeamsApi_ListOrganizationTeamsWithParams_Call struct {
	*mock.Call
}

// ListOrganizationTeamsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListOrganizationTeamsApiParams
func (_e *TeamsApi_Expecter) ListOrganizationTeamsWithParams(ctx interface{}, args interface{}) *TeamsApi_ListOrganizationTeamsWithParams_Call {
	return &TeamsApi_ListOrganizationTeamsWithParams_Call{Call: _e.mock.On("ListOrganizationTeamsWithParams", ctx, args)}
}

func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListOrganizationTeamsApiParams)) *TeamsApi_ListOrganizationTeamsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListOrganizationTeamsApiParams))
	})
	return _c
}

func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) Return(_a0 admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeamsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListOrganizationTeamsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOrganizationTeamsApiParams) admin.ListOrganizationTeamsApiRequest) *TeamsApi_ListOrganizationTeamsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectTeams provides a mock function with given fields: ctx, groupId
func (_m *TeamsApi) ListProjectTeams(ctx context.Context, groupId string) admin.ListProjectTeamsApiRequest {
	ret := _m.Called(ctx, groupId)

	if len(ret) == 0 {
		panic("no return value specified for ListProjectTeams")
	}

	var r0 admin.ListProjectTeamsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListProjectTeamsApiRequest); ok {
		r0 = rf(ctx, groupId)
	} else {
		r0 = ret.Get(0).(admin.ListProjectTeamsApiRequest)
	}

	return r0
}

// TeamsApi_ListProjectTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeams'
type TeamsApi_ListProjectTeams_Call struct {
	*mock.Call
}

// ListProjectTeams is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
func (_e *TeamsApi_Expecter) ListProjectTeams(ctx interface{}, groupId interface{}) *TeamsApi_ListProjectTeams_Call {
	return &TeamsApi_ListProjectTeams_Call{Call: _e.mock.On("ListProjectTeams", ctx, groupId)}
}

func (_c *TeamsApi_ListProjectTeams_Call) Run(run func(ctx context.Context, groupId string)) *TeamsApi_ListProjectTeams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *TeamsApi_ListProjectTeams_Call) Return(_a0 admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListProjectTeams_Call) RunAndReturn(run func(context.Context, string) admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeams_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectTeamsExecute provides a mock function with given fields: r
func (_m *TeamsApi) ListProjectTeamsExecute(r admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListProjectTeamsExecute")
	}

	var r0 *admin.PaginatedTeamRole
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListProjectTeamsApiRequest) *admin.PaginatedTeamRole); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedTeamRole)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListProjectTeamsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListProjectTeamsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_ListProjectTeamsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeamsExecute'
type TeamsApi_ListProjectTeamsExecute_Call struct {
	*mock.Call
}

// ListProjectTeamsExecute is a helper method to define mock.On call
//   - r admin.ListProjectTeamsApiRequest
func (_e *TeamsApi_Expecter) ListProjectTeamsExecute(r interface{}) *TeamsApi_ListProjectTeamsExecute_Call {
	return &TeamsApi_ListProjectTeamsExecute_Call{Call: _e.mock.On("ListProjectTeamsExecute", r)}
}

func (_c *TeamsApi_ListProjectTeamsExecute_Call) Run(run func(r admin.ListProjectTeamsApiRequest)) *TeamsApi_ListProjectTeamsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListProjectTeamsApiRequest))
	})
	return _c
}

func (_c *TeamsApi_ListProjectTeamsExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_ListProjectTeamsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_ListProjectTeamsExecute_Call) RunAndReturn(run func(admin.ListProjectTeamsApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_ListProjectTeamsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectTeamsWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) ListProjectTeamsWithParams(ctx context.Context, args *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListProjectTeamsWithParams")
	}

	var r0 admin.ListProjectTeamsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListProjectTeamsApiRequest)
	}

	return r0
}

// TeamsApi_ListProjectTeamsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjectTeamsWithParams'
type TeamsApi_ListProjectTeamsWithParams_Call struct {
	*mock.Call
}

// ListProjectTeamsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListProjectTeamsApiParams
func (_e *TeamsApi_Expecter) ListProjectTeamsWithParams(ctx interface{}, args interface{}) *TeamsApi_ListProjectTeamsWithParams_Call {
	return &TeamsApi_ListProjectTeamsWithParams_Call{Call: _e.mock.On("ListProjectTeamsWithParams", ctx, args)}
}

func (_c *TeamsApi_ListProjectTeamsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListProjectTeamsApiParams)) *TeamsApi_ListProjectTeamsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListProjectTeamsApiParams))
	})
	return _c
}

func (_c *TeamsApi_ListProjectTeamsWithParams_Call) Return(_a0 admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeamsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListProjectTeamsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectTeamsApiParams) admin.ListProjectTeamsApiRequest) *TeamsApi_ListProjectTeamsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListTeamUsers provides a mock function with given fields: ctx, orgId, teamId
func (_m *TeamsApi) ListTeamUsers(ctx context.Context, orgId string, teamId string) admin.ListTeamUsersApiRequest {
	ret := _m.Called(ctx, orgId, teamId)

	if len(ret) == 0 {
		panic("no return value specified for ListTeamUsers")
	}

	var r0 admin.ListTeamUsersApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ListTeamUsersApiRequest); ok {
		r0 = rf(ctx, orgId, teamId)
	} else {
		r0 = ret.Get(0).(admin.ListTeamUsersApiRequest)
	}

	return r0
}

// TeamsApi_ListTeamUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsers'
type TeamsApi_ListTeamUsers_Call struct {
	*mock.Call
}

// ListTeamUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
func (_e *TeamsApi_Expecter) ListTeamUsers(ctx interface{}, orgId interface{}, teamId interface{}) *TeamsApi_ListTeamUsers_Call {
	return &TeamsApi_ListTeamUsers_Call{Call: _e.mock.On("ListTeamUsers", ctx, orgId, teamId)}
}

func (_c *TeamsApi_ListTeamUsers_Call) Run(run func(ctx context.Context, orgId string, teamId string)) *TeamsApi_ListTeamUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *TeamsApi_ListTeamUsers_Call) Return(_a0 admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListTeamUsers_Call) RunAndReturn(run func(context.Context, string, string) admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsers_Call {
	_c.Call.Return(run)
	return _c
}

// ListTeamUsersExecute provides a mock function with given fields: r
func (_m *TeamsApi) ListTeamUsersExecute(r admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListTeamUsersExecute")
	}

	var r0 *admin.PaginatedApiAppUser
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListTeamUsersApiRequest) *admin.PaginatedApiAppUser); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedApiAppUser)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListTeamUsersApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListTeamUsersApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_ListTeamUsersExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsersExecute'
type TeamsApi_ListTeamUsersExecute_Call struct {
	*mock.Call
}

// ListTeamUsersExecute is a helper method to define mock.On call
//   - r admin.ListTeamUsersApiRequest
func (_e *TeamsApi_Expecter) ListTeamUsersExecute(r interface{}) *TeamsApi_ListTeamUsersExecute_Call {
	return &TeamsApi_ListTeamUsersExecute_Call{Call: _e.mock.On("ListTeamUsersExecute", r)}
}

func (_c *TeamsApi_ListTeamUsersExecute_Call) Run(run func(r admin.ListTeamUsersApiRequest)) *TeamsApi_ListTeamUsersExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListTeamUsersApiRequest))
	})
	return _c
}

func (_c *TeamsApi_ListTeamUsersExecute_Call) Return(_a0 *admin.PaginatedApiAppUser, _a1 *http.Response, _a2 error) *TeamsApi_ListTeamUsersExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_ListTeamUsersExecute_Call) RunAndReturn(run func(admin.ListTeamUsersApiRequest) (*admin.PaginatedApiAppUser, *http.Response, error)) *TeamsApi_ListTeamUsersExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListTeamUsersWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) ListTeamUsersWithParams(ctx context.Context, args *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListTeamUsersWithParams")
	}

	var r0 admin.ListTeamUsersApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListTeamUsersApiRequest)
	}

	return r0
}

// TeamsApi_ListTeamUsersWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTeamUsersWithParams'
type TeamsApi_ListTeamUsersWithParams_Call struct {
	*mock.Call
}

// ListTeamUsersWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListTeamUsersApiParams
func (_e *TeamsApi_Expecter) ListTeamUsersWithParams(ctx interface{}, args interface{}) *TeamsApi_ListTeamUsersWithParams_Call {
	return &TeamsApi_ListTeamUsersWithParams_Call{Call: _e.mock.On("ListTeamUsersWithParams", ctx, args)}
}

func (_c *TeamsApi_ListTeamUsersWithParams_Call) Run(run func(ctx context.Context, args *admin.ListTeamUsersApiParams)) *TeamsApi_ListTeamUsersWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListTeamUsersApiParams))
	})
	return _c
}

func (_c *TeamsApi_ListTeamUsersWithParams_Call) Return(_a0 admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsersWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_ListTeamUsersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListTeamUsersApiParams) admin.ListTeamUsersApiRequest) *TeamsApi_ListTeamUsersWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveProjectTeam provides a mock function with given fields: ctx, groupId, teamId
func (_m *TeamsApi) RemoveProjectTeam(ctx context.Context, groupId string, teamId string) admin.RemoveProjectTeamApiRequest {
	ret := _m.Called(ctx, groupId, teamId)

	if len(ret) == 0 {
		panic("no return value specified for RemoveProjectTeam")
	}

	var r0 admin.RemoveProjectTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.RemoveProjectTeamApiRequest); ok {
		r0 = rf(ctx, groupId, teamId)
	} else {
		r0 = ret.Get(0).(admin.RemoveProjectTeamApiRequest)
	}

	return r0
}

// TeamsApi_RemoveProjectTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeam'
type TeamsApi_RemoveProjectTeam_Call struct {
	*mock.Call
}

// RemoveProjectTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - teamId string
func (_e *TeamsApi_Expecter) RemoveProjectTeam(ctx interface{}, groupId interface{}, teamId interface{}) *TeamsApi_RemoveProjectTeam_Call {
	return &TeamsApi_RemoveProjectTeam_Call{Call: _e.mock.On("RemoveProjectTeam", ctx, groupId, teamId)}
}

func (_c *TeamsApi_RemoveProjectTeam_Call) Run(run func(ctx context.Context, groupId string, teamId string)) *TeamsApi_RemoveProjectTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *TeamsApi_RemoveProjectTeam_Call) Return(_a0 admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RemoveProjectTeam_Call) RunAndReturn(run func(context.Context, string, string) admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeam_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveProjectTeamExecute provides a mock function with given fields: r
func (_m *TeamsApi) RemoveProjectTeamExecute(r admin.RemoveProjectTeamApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RemoveProjectTeamExecute")
	}

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.RemoveProjectTeamApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.RemoveProjectTeamApiRequest) *http.Response); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.RemoveProjectTeamApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TeamsApi_RemoveProjectTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeamExecute'
type TeamsApi_RemoveProjectTeamExecute_Call struct {
	*mock.Call
}

// RemoveProjectTeamExecute is a helper method to define mock.On call
//   - r admin.RemoveProjectTeamApiRequest
func (_e *TeamsApi_Expecter) RemoveProjectTeamExecute(r interface{}) *TeamsApi_RemoveProjectTeamExecute_Call {
	return &TeamsApi_RemoveProjectTeamExecute_Call{Call: _e.mock.On("RemoveProjectTeamExecute", r)}
}

func (_c *TeamsApi_RemoveProjectTeamExecute_Call) Run(run func(r admin.RemoveProjectTeamApiRequest)) *TeamsApi_RemoveProjectTeamExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.RemoveProjectTeamApiRequest))
	})
	return _c
}

func (_c *TeamsApi_RemoveProjectTeamExecute_Call) Return(_a0 *http.Response, _a1 error) *TeamsApi_RemoveProjectTeamExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TeamsApi_RemoveProjectTeamExecute_Call) RunAndReturn(run func(admin.RemoveProjectTeamApiRequest) (*http.Response, error)) *TeamsApi_RemoveProjectTeamExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveProjectTeamWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) RemoveProjectTeamWithParams(ctx context.Context, args *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for RemoveProjectTeamWithParams")
	}

	var r0 admin.RemoveProjectTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.RemoveProjectTeamApiRequest)
	}

	return r0
}

// TeamsApi_RemoveProjectTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveProjectTeamWithParams'
type TeamsApi_RemoveProjectTeamWithParams_Call struct {
	*mock.Call
}

// RemoveProjectTeamWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RemoveProjectTeamApiParams
func (_e *TeamsApi_Expecter) RemoveProjectTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_RemoveProjectTeamWithParams_Call {
	return &TeamsApi_RemoveProjectTeamWithParams_Call{Call: _e.mock.On("RemoveProjectTeamWithParams", ctx, args)}
}

func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveProjectTeamApiParams)) *TeamsApi_RemoveProjectTeamWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.RemoveProjectTeamApiParams))
	})
	return _c
}

func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) Return(_a0 admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeamWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RemoveProjectTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveProjectTeamApiParams) admin.RemoveProjectTeamApiRequest) *TeamsApi_RemoveProjectTeamWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveTeamUser provides a mock function with given fields: ctx, orgId, teamId, userId
func (_m *TeamsApi) RemoveTeamUser(ctx context.Context, orgId string, teamId string, userId string) admin.RemoveTeamUserApiRequest {
	ret := _m.Called(ctx, orgId, teamId, userId)

	if len(ret) == 0 {
		panic("no return value specified for RemoveTeamUser")
	}

	var r0 admin.RemoveTeamUserApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.RemoveTeamUserApiRequest); ok {
		r0 = rf(ctx, orgId, teamId, userId)
	} else {
		r0 = ret.Get(0).(admin.RemoveTeamUserApiRequest)
	}

	return r0
}

// TeamsApi_RemoveTeamUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUser'
type TeamsApi_RemoveTeamUser_Call struct {
	*mock.Call
}

// RemoveTeamUser is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
//   - userId string
func (_e *TeamsApi_Expecter) RemoveTeamUser(ctx interface{}, orgId interface{}, teamId interface{}, userId interface{}) *TeamsApi_RemoveTeamUser_Call {
	return &TeamsApi_RemoveTeamUser_Call{Call: _e.mock.On("RemoveTeamUser", ctx, orgId, teamId, userId)}
}

func (_c *TeamsApi_RemoveTeamUser_Call) Run(run func(ctx context.Context, orgId string, teamId string, userId string)) *TeamsApi_RemoveTeamUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *TeamsApi_RemoveTeamUser_Call) Return(_a0 admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUser_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RemoveTeamUser_Call) RunAndReturn(run func(context.Context, string, string, string) admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUser_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveTeamUserExecute provides a mock function with given fields: r
func (_m *TeamsApi) RemoveTeamUserExecute(r admin.RemoveTeamUserApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RemoveTeamUserExecute")
	}

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.RemoveTeamUserApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.RemoveTeamUserApiRequest) *http.Response); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.RemoveTeamUserApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TeamsApi_RemoveTeamUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUserExecute'
type TeamsApi_RemoveTeamUserExecute_Call struct {
	*mock.Call
}

// RemoveTeamUserExecute is a helper method to define mock.On call
//   - r admin.RemoveTeamUserApiRequest
func (_e *TeamsApi_Expecter) RemoveTeamUserExecute(r interface{}) *TeamsApi_RemoveTeamUserExecute_Call {
	return &TeamsApi_RemoveTeamUserExecute_Call{Call: _e.mock.On("RemoveTeamUserExecute", r)}
}

func (_c *TeamsApi_RemoveTeamUserExecute_Call) Run(run func(r admin.RemoveTeamUserApiRequest)) *TeamsApi_RemoveTeamUserExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.RemoveTeamUserApiRequest))
	})
	return _c
}

func (_c *TeamsApi_RemoveTeamUserExecute_Call) Return(_a0 *http.Response, _a1 error) *TeamsApi_RemoveTeamUserExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TeamsApi_RemoveTeamUserExecute_Call) RunAndReturn(run func(admin.RemoveTeamUserApiRequest) (*http.Response, error)) *TeamsApi_RemoveTeamUserExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveTeamUserWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) RemoveTeamUserWithParams(ctx context.Context, args *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for RemoveTeamUserWithParams")
	}

	var r0 admin.RemoveTeamUserApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.RemoveTeamUserApiRequest)
	}

	return r0
}

// TeamsApi_RemoveTeamUserWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeamUserWithParams'
type TeamsApi_RemoveTeamUserWithParams_Call struct {
	*mock.Call
}

// RemoveTeamUserWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RemoveTeamUserApiParams
func (_e *TeamsApi_Expecter) RemoveTeamUserWithParams(ctx interface{}, args interface{}) *TeamsApi_RemoveTeamUserWithParams_Call {
	return &TeamsApi_RemoveTeamUserWithParams_Call{Call: _e.mock.On("RemoveTeamUserWithParams", ctx, args)}
}

func (_c *TeamsApi_RemoveTeamUserWithParams_Call) Run(run func(ctx context.Context, args *admin.RemoveTeamUserApiParams)) *TeamsApi_RemoveTeamUserWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.RemoveTeamUserApiParams))
	})
	return _c
}

func (_c *TeamsApi_RemoveTeamUserWithParams_Call) Return(_a0 admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUserWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RemoveTeamUserWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveTeamUserApiParams) admin.RemoveTeamUserApiRequest) *TeamsApi_RemoveTeamUserWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RenameTeam provides a mock function with given fields: ctx, orgId, teamId, teamUpdate
func (_m *TeamsApi) RenameTeam(ctx context.Context, orgId string, teamId string, teamUpdate *admin.TeamUpdate) admin.RenameTeamApiRequest {
	ret := _m.Called(ctx, orgId, teamId, teamUpdate)

	if len(ret) == 0 {
		panic("no return value specified for RenameTeam")
	}

	var r0 admin.RenameTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TeamUpdate) admin.RenameTeamApiRequest); ok {
		r0 = rf(ctx, orgId, teamId, teamUpdate)
	} else {
		r0 = ret.Get(0).(admin.RenameTeamApiRequest)
	}

	return r0
}

// TeamsApi_RenameTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeam'
type TeamsApi_RenameTeam_Call struct {
	*mock.Call
}

// RenameTeam is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - teamId string
//   - teamUpdate *admin.TeamUpdate
func (_e *TeamsApi_Expecter) RenameTeam(ctx interface{}, orgId interface{}, teamId interface{}, teamUpdate interface{}) *TeamsApi_RenameTeam_Call {
	return &TeamsApi_RenameTeam_Call{Call: _e.mock.On("RenameTeam", ctx, orgId, teamId, teamUpdate)}
}

func (_c *TeamsApi_RenameTeam_Call) Run(run func(ctx context.Context, orgId string, teamId string, teamUpdate *admin.TeamUpdate)) *TeamsApi_RenameTeam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TeamUpdate))
	})
	return _c
}

func (_c *TeamsApi_RenameTeam_Call) Return(_a0 admin.RenameTeamApiRequest) *TeamsApi_RenameTeam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RenameTeam_Call) RunAndReturn(run func(context.Context, string, string, *admin.TeamUpdate) admin.RenameTeamApiRequest) *TeamsApi_RenameTeam_Call {
	_c.Call.Return(run)
	return _c
}

// RenameTeamExecute provides a mock function with given fields: r
func (_m *TeamsApi) RenameTeamExecute(r admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RenameTeamExecute")
	}

	var r0 *admin.TeamResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.RenameTeamApiRequest) *admin.TeamResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TeamResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.RenameTeamApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.RenameTeamApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_RenameTeamExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeamExecute'
type TeamsApi_RenameTeamExecute_Call struct {
	*mock.Call
}

// RenameTeamExecute is a helper method to define mock.On call
//   - r admin.RenameTeamApiRequest
func (_e *TeamsApi_Expecter) RenameTeamExecute(r interface{}) *TeamsApi_RenameTeamExecute_Call {
	return &TeamsApi_RenameTeamExecute_Call{Call: _e.mock.On("RenameTeamExecute", r)}
}

func (_c *TeamsApi_RenameTeamExecute_Call) Run(run func(r admin.RenameTeamApiRequest)) *TeamsApi_RenameTeamExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.RenameTeamApiRequest))
	})
	return _c
}

func (_c *TeamsApi_RenameTeamExecute_Call) Return(_a0 *admin.TeamResponse, _a1 *http.Response, _a2 error) *TeamsApi_RenameTeamExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_RenameTeamExecute_Call) RunAndReturn(run func(admin.RenameTeamApiRequest) (*admin.TeamResponse, *http.Response, error)) *TeamsApi_RenameTeamExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RenameTeamWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) RenameTeamWithParams(ctx context.Context, args *admin.RenameTeamApiParams) admin.RenameTeamApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for RenameTeamWithParams")
	}

	var r0 admin.RenameTeamApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.RenameTeamApiParams) admin.RenameTeamApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.RenameTeamApiRequest)
	}

	return r0
}

// TeamsApi_RenameTeamWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTeamWithParams'
type TeamsApi_RenameTeamWithParams_Call struct {
	*mock.Call
}

// RenameTeamWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RenameTeamApiParams
func (_e *TeamsApi_Expecter) RenameTeamWithParams(ctx interface{}, args interface{}) *TeamsApi_RenameTeamWithParams_Call {
	return &TeamsApi_RenameTeamWithParams_Call{Call: _e.mock.On("RenameTeamWithParams", ctx, args)}
}

func (_c *TeamsApi_RenameTeamWithParams_Call) Run(run func(ctx context.Context, args *admin.RenameTeamApiParams)) *TeamsApi_RenameTeamWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.RenameTeamApiParams))
	})
	return _c
}

func (_c *TeamsApi_RenameTeamWithParams_Call) Return(_a0 admin.RenameTeamApiRequest) *TeamsApi_RenameTeamWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_RenameTeamWithParams_Call) RunAndReturn(run func(context.Context, *admin.RenameTeamApiParams) admin.RenameTeamApiRequest) *TeamsApi_RenameTeamWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTeamRoles provides a mock function with given fields: ctx, groupId, teamId, teamRole
func (_m *TeamsApi) UpdateTeamRoles(ctx context.Context, groupId string, teamId string, teamRole *admin.TeamRole) admin.UpdateTeamRolesApiRequest {
	ret := _m.Called(ctx, groupId, teamId, teamRole)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTeamRoles")
	}

	var r0 admin.UpdateTeamRolesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.TeamRole) admin.UpdateTeamRolesApiRequest); ok {
		r0 = rf(ctx, groupId, teamId, teamRole)
	} else {
		r0 = ret.Get(0).(admin.UpdateTeamRolesApiRequest)
	}

	return r0
}

// TeamsApi_UpdateTeamRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRoles'
type TeamsApi_UpdateTeamRoles_Call struct {
	*mock.Call
}

// UpdateTeamRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - teamId string
//   - teamRole *admin.TeamRole
func (_e *TeamsApi_Expecter) UpdateTeamRoles(ctx interface{}, groupId interface{}, teamId interface{}, teamRole interface{}) *TeamsApi_UpdateTeamRoles_Call {
	return &TeamsApi_UpdateTeamRoles_Call{Call: _e.mock.On("UpdateTeamRoles", ctx, groupId, teamId, teamRole)}
}

func (_c *TeamsApi_UpdateTeamRoles_Call) Run(run func(ctx context.Context, groupId string, teamId string, teamRole *admin.TeamRole)) *TeamsApi_UpdateTeamRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.TeamRole))
	})
	return _c
}

func (_c *TeamsApi_UpdateTeamRoles_Call) Return(_a0 admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRoles_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_UpdateTeamRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.TeamRole) admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRoles_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTeamRolesExecute provides a mock function with given fields: r
func (_m *TeamsApi) UpdateTeamRolesExecute(r admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTeamRolesExecute")
	}

	var r0 *admin.PaginatedTeamRole
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.UpdateTeamRolesApiRequest) *admin.PaginatedTeamRole); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedTeamRole)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.UpdateTeamRolesApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.UpdateTeamRolesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TeamsApi_UpdateTeamRolesExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRolesExecute'
type TeamsApi_UpdateTeamRolesExecute_Call struct {
	*mock.Call
}

// UpdateTeamRolesExecute is a helper method to define mock.On call
//   - r admin.UpdateTeamRolesApiRequest
func (_e *TeamsApi_Expecter) UpdateTeamRolesExecute(r interface{}) *TeamsApi_UpdateTeamRolesExecute_Call {
	return &TeamsApi_UpdateTeamRolesExecute_Call{Call: _e.mock.On("UpdateTeamRolesExecute", r)}
}

func (_c *TeamsApi_UpdateTeamRolesExecute_Call) Run(run func(r admin.UpdateTeamRolesApiRequest)) *TeamsApi_UpdateTeamRolesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.UpdateTeamRolesApiRequest))
	})
	return _c
}

func (_c *TeamsApi_UpdateTeamRolesExecute_Call) Return(_a0 *admin.PaginatedTeamRole, _a1 *http.Response, _a2 error) *TeamsApi_UpdateTeamRolesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *TeamsApi_UpdateTeamRolesExecute_Call) RunAndReturn(run func(admin.UpdateTeamRolesApiRequest) (*admin.PaginatedTeamRole, *http.Response, error)) *TeamsApi_UpdateTeamRolesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTeamRolesWithParams provides a mock function with given fields: ctx, args
func (_m *TeamsApi) UpdateTeamRolesWithParams(ctx context.Context, args *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTeamRolesWithParams")
	}

	var r0 admin.UpdateTeamRolesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.UpdateTeamRolesApiRequest)
	}

	return r0
}

// TeamsApi_UpdateTeamRolesWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamRolesWithParams'
type TeamsApi_UpdateTeamRolesWithParams_Call struct {
	*mock.Call
}

// UpdateTeamRolesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateTeamRolesApiParams
func (_e *TeamsApi_Expecter) UpdateTeamRolesWithParams(ctx interface{}, args interface{}) *TeamsApi_UpdateTeamRolesWithParams_Call {
	return &TeamsApi_UpdateTeamRolesWithParams_Call{Call: _e.mock.On("UpdateTeamRolesWithParams", ctx, args)}
}

func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateTeamRolesApiParams)) *TeamsApi_UpdateTeamRolesWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.UpdateTeamRolesApiParams))
	})
	return _c
}

func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) Return(_a0 admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRolesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *TeamsApi_UpdateTeamRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateTeamRolesApiParams) admin.UpdateTeamRolesApiRequest) *TeamsApi_UpdateTeamRolesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewTeamsApi creates a new instance of TeamsApi. 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 NewTeamsApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *TeamsApi {
	mock := &TeamsApi{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}