//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloudstack/ProjectService.go
//
// Generated by this command:
//
//	mockgen -destination=./cloudstack/ProjectService_mock.go -package=cloudstack -copyright_file=header.txt -source=./cloudstack/ProjectService.go
//

// Package cloudstack is a generated GoMock package.
package cloudstack

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockProjectServiceIface is a mock of ProjectServiceIface interface.
type MockProjectServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockProjectServiceIfaceMockRecorder
	isgomock struct{}
}

// MockProjectServiceIfaceMockRecorder is the mock recorder for MockProjectServiceIface.
type MockProjectServiceIfaceMockRecorder struct {
	mock *MockProjectServiceIface
}

// NewMockProjectServiceIface creates a new mock instance.
func NewMockProjectServiceIface(ctrl *gomock.Controller) *MockProjectServiceIface {
	mock := &MockProjectServiceIface{ctrl: ctrl}
	mock.recorder = &MockProjectServiceIfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProjectServiceIface) EXPECT() *MockProjectServiceIfaceMockRecorder {
	return m.recorder
}

// ActivateProject mocks base method.
func (m *MockProjectServiceIface) ActivateProject(p *ActivateProjectParams) (*ActivateProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateProject", p)
	ret0, _ := ret[0].(*ActivateProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ActivateProject indicates an expected call of ActivateProject.
func (mr *MockProjectServiceIfaceMockRecorder) ActivateProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateProject", reflect.TypeOf((*MockProjectServiceIface)(nil).ActivateProject), p)
}

// AddAccountToProject mocks base method.
func (m *MockProjectServiceIface) AddAccountToProject(p *AddAccountToProjectParams) (*AddAccountToProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAccountToProject", p)
	ret0, _ := ret[0].(*AddAccountToProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddAccountToProject indicates an expected call of AddAccountToProject.
func (mr *MockProjectServiceIfaceMockRecorder) AddAccountToProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAccountToProject", reflect.TypeOf((*MockProjectServiceIface)(nil).AddAccountToProject), p)
}

// AddUserToProject mocks base method.
func (m *MockProjectServiceIface) AddUserToProject(p *AddUserToProjectParams) (*AddUserToProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddUserToProject", p)
	ret0, _ := ret[0].(*AddUserToProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddUserToProject indicates an expected call of AddUserToProject.
func (mr *MockProjectServiceIfaceMockRecorder) AddUserToProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUserToProject", reflect.TypeOf((*MockProjectServiceIface)(nil).AddUserToProject), p)
}

// CreateProject mocks base method.
func (m *MockProjectServiceIface) CreateProject(p *CreateProjectParams) (*CreateProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProject", p)
	ret0, _ := ret[0].(*CreateProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProject indicates an expected call of CreateProject.
func (mr *MockProjectServiceIfaceMockRecorder) CreateProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockProjectServiceIface)(nil).CreateProject), p)
}

// CreateProjectRole mocks base method.
func (m *MockProjectServiceIface) CreateProjectRole(p *CreateProjectRoleParams) (*CreateProjectRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProjectRole", p)
	ret0, _ := ret[0].(*CreateProjectRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProjectRole indicates an expected call of CreateProjectRole.
func (mr *MockProjectServiceIfaceMockRecorder) CreateProjectRole(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectRole", reflect.TypeOf((*MockProjectServiceIface)(nil).CreateProjectRole), p)
}

// CreateProjectRolePermission mocks base method.
func (m *MockProjectServiceIface) CreateProjectRolePermission(p *CreateProjectRolePermissionParams) (*CreateProjectRolePermissionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProjectRolePermission", p)
	ret0, _ := ret[0].(*CreateProjectRolePermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProjectRolePermission indicates an expected call of CreateProjectRolePermission.
func (mr *MockProjectServiceIfaceMockRecorder) CreateProjectRolePermission(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectRolePermission", reflect.TypeOf((*MockProjectServiceIface)(nil).CreateProjectRolePermission), p)
}

// DeleteAccountFromProject mocks base method.
func (m *MockProjectServiceIface) DeleteAccountFromProject(p *DeleteAccountFromProjectParams) (*DeleteAccountFromProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountFromProject", p)
	ret0, _ := ret[0].(*DeleteAccountFromProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAccountFromProject indicates an expected call of DeleteAccountFromProject.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteAccountFromProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountFromProject", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteAccountFromProject), p)
}

// DeleteProject mocks base method.
func (m *MockProjectServiceIface) DeleteProject(p *DeleteProjectParams) (*DeleteProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProject", p)
	ret0, _ := ret[0].(*DeleteProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteProject indicates an expected call of DeleteProject.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProject", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteProject), p)
}

// DeleteProjectInvitation mocks base method.
func (m *MockProjectServiceIface) DeleteProjectInvitation(p *DeleteProjectInvitationParams) (*DeleteProjectInvitationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProjectInvitation", p)
	ret0, _ := ret[0].(*DeleteProjectInvitationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteProjectInvitation indicates an expected call of DeleteProjectInvitation.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteProjectInvitation(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProjectInvitation", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteProjectInvitation), p)
}

// DeleteProjectRole mocks base method.
func (m *MockProjectServiceIface) DeleteProjectRole(p *DeleteProjectRoleParams) (*DeleteProjectRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProjectRole", p)
	ret0, _ := ret[0].(*DeleteProjectRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteProjectRole indicates an expected call of DeleteProjectRole.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteProjectRole(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProjectRole", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteProjectRole), p)
}

// DeleteProjectRolePermission mocks base method.
func (m *MockProjectServiceIface) DeleteProjectRolePermission(p *DeleteProjectRolePermissionParams) (*DeleteProjectRolePermissionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProjectRolePermission", p)
	ret0, _ := ret[0].(*DeleteProjectRolePermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteProjectRolePermission indicates an expected call of DeleteProjectRolePermission.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteProjectRolePermission(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProjectRolePermission", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteProjectRolePermission), p)
}

// DeleteUserFromProject mocks base method.
func (m *MockProjectServiceIface) DeleteUserFromProject(p *DeleteUserFromProjectParams) (*DeleteUserFromProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserFromProject", p)
	ret0, _ := ret[0].(*DeleteUserFromProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUserFromProject indicates an expected call of DeleteUserFromProject.
func (mr *MockProjectServiceIfaceMockRecorder) DeleteUserFromProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserFromProject", reflect.TypeOf((*MockProjectServiceIface)(nil).DeleteUserFromProject), p)
}

// GetProjectByID mocks base method.
func (m *MockProjectServiceIface) GetProjectByID(id string, opts ...OptionFunc) (*Project, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectByID", varargs...)
	ret0, _ := ret[0].(*Project)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProjectByID indicates an expected call of GetProjectByID.
func (mr *MockProjectServiceIfaceMockRecorder) GetProjectByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectByID", reflect.TypeOf((*MockProjectServiceIface)(nil).GetProjectByID), varargs...)
}

// GetProjectByName mocks base method.
func (m *MockProjectServiceIface) GetProjectByName(name string, opts ...OptionFunc) (*Project, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectByName", varargs...)
	ret0, _ := ret[0].(*Project)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProjectByName indicates an expected call of GetProjectByName.
func (mr *MockProjectServiceIfaceMockRecorder) GetProjectByName(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectByName", reflect.TypeOf((*MockProjectServiceIface)(nil).GetProjectByName), varargs...)
}

// GetProjectID mocks base method.
func (m *MockProjectServiceIface) GetProjectID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProjectID indicates an expected call of GetProjectID.
func (mr *MockProjectServiceIfaceMockRecorder) GetProjectID(name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectID", reflect.TypeOf((*MockProjectServiceIface)(nil).GetProjectID), varargs...)
}

// GetProjectInvitationByID mocks base method.
func (m *MockProjectServiceIface) GetProjectInvitationByID(id string, opts ...OptionFunc) (*ProjectInvitation, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectInvitationByID", varargs...)
	ret0, _ := ret[0].(*ProjectInvitation)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProjectInvitationByID indicates an expected call of GetProjectInvitationByID.
func (mr *MockProjectServiceIfaceMockRecorder) GetProjectInvitationByID(id any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectInvitationByID", reflect.TypeOf((*MockProjectServiceIface)(nil).GetProjectInvitationByID), varargs...)
}

// ListProjectInvitations mocks base method.
func (m *MockProjectServiceIface) ListProjectInvitations(p *ListProjectInvitationsParams) (*ListProjectInvitationsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectInvitations", p)
	ret0, _ := ret[0].(*ListProjectInvitationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectInvitations indicates an expected call of ListProjectInvitations.
func (mr *MockProjectServiceIfaceMockRecorder) ListProjectInvitations(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectInvitations", reflect.TypeOf((*MockProjectServiceIface)(nil).ListProjectInvitations), p)
}

// ListProjectRolePermissions mocks base method.
func (m *MockProjectServiceIface) ListProjectRolePermissions(p *ListProjectRolePermissionsParams) (*ListProjectRolePermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectRolePermissions", p)
	ret0, _ := ret[0].(*ListProjectRolePermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectRolePermissions indicates an expected call of ListProjectRolePermissions.
func (mr *MockProjectServiceIfaceMockRecorder) ListProjectRolePermissions(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectRolePermissions", reflect.TypeOf((*MockProjectServiceIface)(nil).ListProjectRolePermissions), p)
}

// ListProjects mocks base method.
func (m *MockProjectServiceIface) ListProjects(p *ListProjectsParams) (*ListProjectsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjects", p)
	ret0, _ := ret[0].(*ListProjectsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjects indicates an expected call of ListProjects.
func (mr *MockProjectServiceIfaceMockRecorder) ListProjects(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjects", reflect.TypeOf((*MockProjectServiceIface)(nil).ListProjects), p)
}

// NewActivateProjectParams mocks base method.
func (m *MockProjectServiceIface) NewActivateProjectParams(id string) *ActivateProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewActivateProjectParams", id)
	ret0, _ := ret[0].(*ActivateProjectParams)
	return ret0
}

// NewActivateProjectParams indicates an expected call of NewActivateProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewActivateProjectParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewActivateProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewActivateProjectParams), id)
}

// NewAddAccountToProjectParams mocks base method.
func (m *MockProjectServiceIface) NewAddAccountToProjectParams(projectid string) *AddAccountToProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddAccountToProjectParams", projectid)
	ret0, _ := ret[0].(*AddAccountToProjectParams)
	return ret0
}

// NewAddAccountToProjectParams indicates an expected call of NewAddAccountToProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewAddAccountToProjectParams(projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddAccountToProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewAddAccountToProjectParams), projectid)
}

// NewAddUserToProjectParams mocks base method.
func (m *MockProjectServiceIface) NewAddUserToProjectParams(projectid, username string) *AddUserToProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddUserToProjectParams", projectid, username)
	ret0, _ := ret[0].(*AddUserToProjectParams)
	return ret0
}

// NewAddUserToProjectParams indicates an expected call of NewAddUserToProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewAddUserToProjectParams(projectid, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddUserToProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewAddUserToProjectParams), projectid, username)
}

// NewCreateProjectParams mocks base method.
func (m *MockProjectServiceIface) NewCreateProjectParams(displaytext, name string) *CreateProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateProjectParams", displaytext, name)
	ret0, _ := ret[0].(*CreateProjectParams)
	return ret0
}

// NewCreateProjectParams indicates an expected call of NewCreateProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewCreateProjectParams(displaytext, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewCreateProjectParams), displaytext, name)
}

// NewCreateProjectRoleParams mocks base method.
func (m *MockProjectServiceIface) NewCreateProjectRoleParams(name, projectid string) *CreateProjectRoleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateProjectRoleParams", name, projectid)
	ret0, _ := ret[0].(*CreateProjectRoleParams)
	return ret0
}

// NewCreateProjectRoleParams indicates an expected call of NewCreateProjectRoleParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewCreateProjectRoleParams(name, projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateProjectRoleParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewCreateProjectRoleParams), name, projectid)
}

// NewCreateProjectRolePermissionParams mocks base method.
func (m *MockProjectServiceIface) NewCreateProjectRolePermissionParams(permission, projectid, projectroleid, rule string) *CreateProjectRolePermissionParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateProjectRolePermissionParams", permission, projectid, projectroleid, rule)
	ret0, _ := ret[0].(*CreateProjectRolePermissionParams)
	return ret0
}

// NewCreateProjectRolePermissionParams indicates an expected call of NewCreateProjectRolePermissionParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewCreateProjectRolePermissionParams(permission, projectid, projectroleid, rule any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateProjectRolePermissionParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewCreateProjectRolePermissionParams), permission, projectid, projectroleid, rule)
}

// NewDeleteAccountFromProjectParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteAccountFromProjectParams(account, projectid string) *DeleteAccountFromProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteAccountFromProjectParams", account, projectid)
	ret0, _ := ret[0].(*DeleteAccountFromProjectParams)
	return ret0
}

// NewDeleteAccountFromProjectParams indicates an expected call of NewDeleteAccountFromProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteAccountFromProjectParams(account, projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteAccountFromProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteAccountFromProjectParams), account, projectid)
}

// NewDeleteProjectInvitationParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteProjectInvitationParams(id string) *DeleteProjectInvitationParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteProjectInvitationParams", id)
	ret0, _ := ret[0].(*DeleteProjectInvitationParams)
	return ret0
}

// NewDeleteProjectInvitationParams indicates an expected call of NewDeleteProjectInvitationParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteProjectInvitationParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteProjectInvitationParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteProjectInvitationParams), id)
}

// NewDeleteProjectParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteProjectParams(id string) *DeleteProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteProjectParams", id)
	ret0, _ := ret[0].(*DeleteProjectParams)
	return ret0
}

// NewDeleteProjectParams indicates an expected call of NewDeleteProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteProjectParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteProjectParams), id)
}

// NewDeleteProjectRoleParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteProjectRoleParams(id, projectid string) *DeleteProjectRoleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteProjectRoleParams", id, projectid)
	ret0, _ := ret[0].(*DeleteProjectRoleParams)
	return ret0
}

// NewDeleteProjectRoleParams indicates an expected call of NewDeleteProjectRoleParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteProjectRoleParams(id, projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteProjectRoleParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteProjectRoleParams), id, projectid)
}

// NewDeleteProjectRolePermissionParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteProjectRolePermissionParams(id, projectid string) *DeleteProjectRolePermissionParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteProjectRolePermissionParams", id, projectid)
	ret0, _ := ret[0].(*DeleteProjectRolePermissionParams)
	return ret0
}

// NewDeleteProjectRolePermissionParams indicates an expected call of NewDeleteProjectRolePermissionParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteProjectRolePermissionParams(id, projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteProjectRolePermissionParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteProjectRolePermissionParams), id, projectid)
}

// NewDeleteUserFromProjectParams mocks base method.
func (m *MockProjectServiceIface) NewDeleteUserFromProjectParams(projectid, userid string) *DeleteUserFromProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteUserFromProjectParams", projectid, userid)
	ret0, _ := ret[0].(*DeleteUserFromProjectParams)
	return ret0
}

// NewDeleteUserFromProjectParams indicates an expected call of NewDeleteUserFromProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewDeleteUserFromProjectParams(projectid, userid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteUserFromProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewDeleteUserFromProjectParams), projectid, userid)
}

// NewListProjectInvitationsParams mocks base method.
func (m *MockProjectServiceIface) NewListProjectInvitationsParams() *ListProjectInvitationsParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListProjectInvitationsParams")
	ret0, _ := ret[0].(*ListProjectInvitationsParams)
	return ret0
}

// NewListProjectInvitationsParams indicates an expected call of NewListProjectInvitationsParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewListProjectInvitationsParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListProjectInvitationsParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewListProjectInvitationsParams))
}

// NewListProjectRolePermissionsParams mocks base method.
func (m *MockProjectServiceIface) NewListProjectRolePermissionsParams(projectid string) *ListProjectRolePermissionsParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListProjectRolePermissionsParams", projectid)
	ret0, _ := ret[0].(*ListProjectRolePermissionsParams)
	return ret0
}

// NewListProjectRolePermissionsParams indicates an expected call of NewListProjectRolePermissionsParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewListProjectRolePermissionsParams(projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListProjectRolePermissionsParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewListProjectRolePermissionsParams), projectid)
}

// NewListProjectsParams mocks base method.
func (m *MockProjectServiceIface) NewListProjectsParams() *ListProjectsParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListProjectsParams")
	ret0, _ := ret[0].(*ListProjectsParams)
	return ret0
}

// NewListProjectsParams indicates an expected call of NewListProjectsParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewListProjectsParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListProjectsParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewListProjectsParams))
}

// NewSuspendProjectParams mocks base method.
func (m *MockProjectServiceIface) NewSuspendProjectParams(id string) *SuspendProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSuspendProjectParams", id)
	ret0, _ := ret[0].(*SuspendProjectParams)
	return ret0
}

// NewSuspendProjectParams indicates an expected call of NewSuspendProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewSuspendProjectParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSuspendProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewSuspendProjectParams), id)
}

// NewUpdateProjectInvitationParams mocks base method.
func (m *MockProjectServiceIface) NewUpdateProjectInvitationParams(projectid string) *UpdateProjectInvitationParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateProjectInvitationParams", projectid)
	ret0, _ := ret[0].(*UpdateProjectInvitationParams)
	return ret0
}

// NewUpdateProjectInvitationParams indicates an expected call of NewUpdateProjectInvitationParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewUpdateProjectInvitationParams(projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateProjectInvitationParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewUpdateProjectInvitationParams), projectid)
}

// NewUpdateProjectParams mocks base method.
func (m *MockProjectServiceIface) NewUpdateProjectParams(id string) *UpdateProjectParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateProjectParams", id)
	ret0, _ := ret[0].(*UpdateProjectParams)
	return ret0
}

// NewUpdateProjectParams indicates an expected call of NewUpdateProjectParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewUpdateProjectParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateProjectParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewUpdateProjectParams), id)
}

// NewUpdateProjectRoleParams mocks base method.
func (m *MockProjectServiceIface) NewUpdateProjectRoleParams(id, projectid string) *UpdateProjectRoleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateProjectRoleParams", id, projectid)
	ret0, _ := ret[0].(*UpdateProjectRoleParams)
	return ret0
}

// NewUpdateProjectRoleParams indicates an expected call of NewUpdateProjectRoleParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewUpdateProjectRoleParams(id, projectid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateProjectRoleParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewUpdateProjectRoleParams), id, projectid)
}

// NewUpdateProjectRolePermissionParams mocks base method.
func (m *MockProjectServiceIface) NewUpdateProjectRolePermissionParams(projectid, projectroleid string) *UpdateProjectRolePermissionParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateProjectRolePermissionParams", projectid, projectroleid)
	ret0, _ := ret[0].(*UpdateProjectRolePermissionParams)
	return ret0
}

// NewUpdateProjectRolePermissionParams indicates an expected call of NewUpdateProjectRolePermissionParams.
func (mr *MockProjectServiceIfaceMockRecorder) NewUpdateProjectRolePermissionParams(projectid, projectroleid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateProjectRolePermissionParams", reflect.TypeOf((*MockProjectServiceIface)(nil).NewUpdateProjectRolePermissionParams), projectid, projectroleid)
}

// SuspendProject mocks base method.
func (m *MockProjectServiceIface) SuspendProject(p *SuspendProjectParams) (*SuspendProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuspendProject", p)
	ret0, _ := ret[0].(*SuspendProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SuspendProject indicates an expected call of SuspendProject.
func (mr *MockProjectServiceIfaceMockRecorder) SuspendProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProject", reflect.TypeOf((*MockProjectServiceIface)(nil).SuspendProject), p)
}

// UpdateProject mocks base method.
func (m *MockProjectServiceIface) UpdateProject(p *UpdateProjectParams) (*UpdateProjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProject", p)
	ret0, _ := ret[0].(*UpdateProjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProject indicates an expected call of UpdateProject.
func (mr *MockProjectServiceIfaceMockRecorder) UpdateProject(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockProjectServiceIface)(nil).UpdateProject), p)
}

// UpdateProjectInvitation mocks base method.
func (m *MockProjectServiceIface) UpdateProjectInvitation(p *UpdateProjectInvitationParams) (*UpdateProjectInvitationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProjectInvitation", p)
	ret0, _ := ret[0].(*UpdateProjectInvitationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProjectInvitation indicates an expected call of UpdateProjectInvitation.
func (mr *MockProjectServiceIfaceMockRecorder) UpdateProjectInvitation(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectInvitation", reflect.TypeOf((*MockProjectServiceIface)(nil).UpdateProjectInvitation), p)
}

// UpdateProjectRole mocks base method.
func (m *MockProjectServiceIface) UpdateProjectRole(p *UpdateProjectRoleParams) (*UpdateProjectRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProjectRole", p)
	ret0, _ := ret[0].(*UpdateProjectRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProjectRole indicates an expected call of UpdateProjectRole.
func (mr *MockProjectServiceIfaceMockRecorder) UpdateProjectRole(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectRole", reflect.TypeOf((*MockProjectServiceIface)(nil).UpdateProjectRole), p)
}

// UpdateProjectRolePermission mocks base method.
func (m *MockProjectServiceIface) UpdateProjectRolePermission(p *UpdateProjectRolePermissionParams) (*UpdateProjectRolePermissionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProjectRolePermission", p)
	ret0, _ := ret[0].(*UpdateProjectRolePermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProjectRolePermission indicates an expected call of UpdateProjectRolePermission.
func (mr *MockProjectServiceIfaceMockRecorder) UpdateProjectRolePermission(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectRolePermission", reflect.TypeOf((*MockProjectServiceIface)(nil).UpdateProjectRolePermission), p)
}