mock_config.go

// Code generated by MockGen. DO NOT EDIT.
// Source: config.go

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

import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	build "github.com/microsoft/azure-devops-go-api/azuredevops/build"
	core "github.com/microsoft/azure-devops-go-api/azuredevops/core"
	operations "github.com/microsoft/azure-devops-go-api/azuredevops/operations"
	serviceendpoint "github.com/microsoft/azure-devops-go-api/azuredevops/serviceendpoint"
	webapi "github.com/microsoft/azure-devops-go-api/azuredevops/webapi"
	io "io"
	reflect "reflect"
)

// MockBuildClient is a mock of BuildClient interface
type MockBuildClient struct {
	ctrl     *gomock.Controller
	recorder *MockBuildClientMockRecorder
}

// MockBuildClientMockRecorder is the mock recorder for MockBuildClient
type MockBuildClientMockRecorder struct {
	mock *MockBuildClient
}

// NewMockBuildClient creates a new mock instance
func NewMockBuildClient(ctrl *gomock.Controller) *MockBuildClient {
	mock := &MockBuildClient{ctrl: ctrl}
	mock.recorder = &MockBuildClientMockRecorder{mock}
	return mock
}

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

// CreateArtifact mocks base method
func (m *MockBuildClient) CreateArtifact(ctx context.Context, args build.CreateArtifactArgs) (*build.BuildArtifact, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateArtifact", ctx, args)
	ret0, _ := ret[0].(*build.BuildArtifact)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateArtifact indicates an expected call of CreateArtifact
func (mr *MockBuildClientMockRecorder) CreateArtifact(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateArtifact", reflect.TypeOf((*MockBuildClient)(nil).CreateArtifact), ctx, args)
}

// GetArtifact mocks base method
func (m *MockBuildClient) GetArtifact(ctx context.Context, args build.GetArtifactArgs) (*build.BuildArtifact, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifact", ctx, args)
	ret0, _ := ret[0].(*build.BuildArtifact)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifact indicates an expected call of GetArtifact
func (mr *MockBuildClientMockRecorder) GetArtifact(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifact", reflect.TypeOf((*MockBuildClient)(nil).GetArtifact), ctx, args)
}

// GetArtifactContentZip mocks base method
func (m *MockBuildClient) GetArtifactContentZip(ctx context.Context, args build.GetArtifactContentZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifactContentZip", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifactContentZip indicates an expected call of GetArtifactContentZip
func (mr *MockBuildClientMockRecorder) GetArtifactContentZip(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifactContentZip", reflect.TypeOf((*MockBuildClient)(nil).GetArtifactContentZip), ctx, args)
}

// GetArtifacts mocks base method
func (m *MockBuildClient) GetArtifacts(ctx context.Context, args build.GetArtifactsArgs) (*[]build.BuildArtifact, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifacts", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildArtifact)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetArtifacts indicates an expected call of GetArtifacts
func (mr *MockBuildClientMockRecorder) GetArtifacts(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArtifacts", reflect.TypeOf((*MockBuildClient)(nil).GetArtifacts), ctx, args)
}

// GetFile mocks base method
func (m *MockBuildClient) GetFile(ctx context.Context, args build.GetFileArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFile", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFile indicates an expected call of GetFile
func (mr *MockBuildClientMockRecorder) GetFile(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFile", reflect.TypeOf((*MockBuildClient)(nil).GetFile), ctx, args)
}

// GetAttachments mocks base method
func (m *MockBuildClient) GetAttachments(ctx context.Context, args build.GetAttachmentsArgs) (*[]build.Attachment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachments", ctx, args)
	ret0, _ := ret[0].(*[]build.Attachment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttachments indicates an expected call of GetAttachments
func (mr *MockBuildClientMockRecorder) GetAttachments(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachments", reflect.TypeOf((*MockBuildClient)(nil).GetAttachments), ctx, args)
}

// GetAttachment mocks base method
func (m *MockBuildClient) GetAttachment(ctx context.Context, args build.GetAttachmentArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttachment", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttachment indicates an expected call of GetAttachment
func (mr *MockBuildClientMockRecorder) GetAttachment(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttachment", reflect.TypeOf((*MockBuildClient)(nil).GetAttachment), ctx, args)
}

// AuthorizeProjectResources mocks base method
func (m *MockBuildClient) AuthorizeProjectResources(ctx context.Context, args build.AuthorizeProjectResourcesArgs) (*[]build.DefinitionResourceReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeProjectResources", ctx, args)
	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeProjectResources indicates an expected call of AuthorizeProjectResources
func (mr *MockBuildClientMockRecorder) AuthorizeProjectResources(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeProjectResources", reflect.TypeOf((*MockBuildClient)(nil).AuthorizeProjectResources), ctx, args)
}

// GetProjectResources mocks base method
func (m *MockBuildClient) GetProjectResources(ctx context.Context, args build.GetProjectResourcesArgs) (*[]build.DefinitionResourceReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectResources", ctx, args)
	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectResources indicates an expected call of GetProjectResources
func (mr *MockBuildClientMockRecorder) GetProjectResources(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectResources", reflect.TypeOf((*MockBuildClient)(nil).GetProjectResources), ctx, args)
}

// ListBranches mocks base method
func (m *MockBuildClient) ListBranches(ctx context.Context, args build.ListBranchesArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBranches indicates an expected call of ListBranches
func (mr *MockBuildClientMockRecorder) ListBranches(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockBuildClient)(nil).ListBranches), ctx, args)
}

// GetBuildBadge mocks base method
func (m *MockBuildClient) GetBuildBadge(ctx context.Context, args build.GetBuildBadgeArgs) (*build.BuildBadge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildBadge", ctx, args)
	ret0, _ := ret[0].(*build.BuildBadge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildBadge indicates an expected call of GetBuildBadge
func (mr *MockBuildClientMockRecorder) GetBuildBadge(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildBadge", reflect.TypeOf((*MockBuildClient)(nil).GetBuildBadge), ctx, args)
}

// GetBuildBadgeData mocks base method
func (m *MockBuildClient) GetBuildBadgeData(ctx context.Context, args build.GetBuildBadgeDataArgs) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildBadgeData", ctx, args)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildBadgeData indicates an expected call of GetBuildBadgeData
func (mr *MockBuildClientMockRecorder) GetBuildBadgeData(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildBadgeData", reflect.TypeOf((*MockBuildClient)(nil).GetBuildBadgeData), ctx, args)
}

// DeleteBuild mocks base method
func (m *MockBuildClient) DeleteBuild(ctx context.Context, args build.DeleteBuildArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBuild", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBuild indicates an expected call of DeleteBuild
func (mr *MockBuildClientMockRecorder) DeleteBuild(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuild", reflect.TypeOf((*MockBuildClient)(nil).DeleteBuild), ctx, args)
}

// GetBuild mocks base method
func (m *MockBuildClient) GetBuild(ctx context.Context, args build.GetBuildArgs) (*build.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuild", ctx, args)
	ret0, _ := ret[0].(*build.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuild indicates an expected call of GetBuild
func (mr *MockBuildClientMockRecorder) GetBuild(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuild", reflect.TypeOf((*MockBuildClient)(nil).GetBuild), ctx, args)
}

// GetBuilds mocks base method
func (m *MockBuildClient) GetBuilds(ctx context.Context, args build.GetBuildsArgs) (*build.GetBuildsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuilds", ctx, args)
	ret0, _ := ret[0].(*build.GetBuildsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuilds indicates an expected call of GetBuilds
func (mr *MockBuildClientMockRecorder) GetBuilds(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetBuilds), ctx, args)
}

// QueueBuild mocks base method
func (m *MockBuildClient) QueueBuild(ctx context.Context, args build.QueueBuildArgs) (*build.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueueBuild", ctx, args)
	ret0, _ := ret[0].(*build.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueueBuild indicates an expected call of QueueBuild
func (mr *MockBuildClientMockRecorder) QueueBuild(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueBuild", reflect.TypeOf((*MockBuildClient)(nil).QueueBuild), ctx, args)
}

// UpdateBuild mocks base method
func (m *MockBuildClient) UpdateBuild(ctx context.Context, args build.UpdateBuildArgs) (*build.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuild", ctx, args)
	ret0, _ := ret[0].(*build.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBuild indicates an expected call of UpdateBuild
func (mr *MockBuildClientMockRecorder) UpdateBuild(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuild", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuild), ctx, args)
}

// UpdateBuilds mocks base method
func (m *MockBuildClient) UpdateBuilds(ctx context.Context, args build.UpdateBuildsArgs) (*[]build.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuilds", ctx, args)
	ret0, _ := ret[0].(*[]build.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBuilds indicates an expected call of UpdateBuilds
func (mr *MockBuildClientMockRecorder) UpdateBuilds(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuilds", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuilds), ctx, args)
}

// GetBuildChanges mocks base method
func (m *MockBuildClient) GetBuildChanges(ctx context.Context, args build.GetBuildChangesArgs) (*build.GetBuildChangesResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildChanges", ctx, args)
	ret0, _ := ret[0].(*build.GetBuildChangesResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildChanges indicates an expected call of GetBuildChanges
func (mr *MockBuildClientMockRecorder) GetBuildChanges(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildChanges", reflect.TypeOf((*MockBuildClient)(nil).GetBuildChanges), ctx, args)
}

// GetChangesBetweenBuilds mocks base method
func (m *MockBuildClient) GetChangesBetweenBuilds(ctx context.Context, args build.GetChangesBetweenBuildsArgs) (*[]build.Change, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChangesBetweenBuilds", ctx, args)
	ret0, _ := ret[0].(*[]build.Change)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChangesBetweenBuilds indicates an expected call of GetChangesBetweenBuilds
func (mr *MockBuildClientMockRecorder) GetChangesBetweenBuilds(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangesBetweenBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetChangesBetweenBuilds), ctx, args)
}

// GetBuildController mocks base method
func (m *MockBuildClient) GetBuildController(ctx context.Context, args build.GetBuildControllerArgs) (*build.BuildController, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildController", ctx, args)
	ret0, _ := ret[0].(*build.BuildController)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildController indicates an expected call of GetBuildController
func (mr *MockBuildClientMockRecorder) GetBuildController(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildController", reflect.TypeOf((*MockBuildClient)(nil).GetBuildController), ctx, args)
}

// GetBuildControllers mocks base method
func (m *MockBuildClient) GetBuildControllers(ctx context.Context, args build.GetBuildControllersArgs) (*[]build.BuildController, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildControllers", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildController)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildControllers indicates an expected call of GetBuildControllers
func (mr *MockBuildClientMockRecorder) GetBuildControllers(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildControllers", reflect.TypeOf((*MockBuildClient)(nil).GetBuildControllers), ctx, args)
}

// CreateDefinition mocks base method
func (m *MockBuildClient) CreateDefinition(ctx context.Context, args build.CreateDefinitionArgs) (*build.BuildDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDefinition", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDefinition indicates an expected call of CreateDefinition
func (mr *MockBuildClientMockRecorder) CreateDefinition(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefinition", reflect.TypeOf((*MockBuildClient)(nil).CreateDefinition), ctx, args)
}

// DeleteDefinition mocks base method
func (m *MockBuildClient) DeleteDefinition(ctx context.Context, args build.DeleteDefinitionArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDefinition", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDefinition indicates an expected call of DeleteDefinition
func (mr *MockBuildClientMockRecorder) DeleteDefinition(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefinition", reflect.TypeOf((*MockBuildClient)(nil).DeleteDefinition), ctx, args)
}

// GetDefinition mocks base method
func (m *MockBuildClient) GetDefinition(ctx context.Context, args build.GetDefinitionArgs) (*build.BuildDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinition", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinition indicates an expected call of GetDefinition
func (mr *MockBuildClientMockRecorder) GetDefinition(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinition", reflect.TypeOf((*MockBuildClient)(nil).GetDefinition), ctx, args)
}

// GetDefinitions mocks base method
func (m *MockBuildClient) GetDefinitions(ctx context.Context, args build.GetDefinitionsArgs) (*build.GetDefinitionsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitions", ctx, args)
	ret0, _ := ret[0].(*build.GetDefinitionsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitions indicates an expected call of GetDefinitions
func (mr *MockBuildClientMockRecorder) GetDefinitions(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitions", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitions), ctx, args)
}

// RestoreDefinition mocks base method
func (m *MockBuildClient) RestoreDefinition(ctx context.Context, args build.RestoreDefinitionArgs) (*build.BuildDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreDefinition", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreDefinition indicates an expected call of RestoreDefinition
func (mr *MockBuildClientMockRecorder) RestoreDefinition(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreDefinition", reflect.TypeOf((*MockBuildClient)(nil).RestoreDefinition), ctx, args)
}

// UpdateDefinition mocks base method
func (m *MockBuildClient) UpdateDefinition(ctx context.Context, args build.UpdateDefinitionArgs) (*build.BuildDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDefinition", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDefinition indicates an expected call of UpdateDefinition
func (mr *MockBuildClientMockRecorder) UpdateDefinition(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDefinition", reflect.TypeOf((*MockBuildClient)(nil).UpdateDefinition), ctx, args)
}

// GetFileContents mocks base method
func (m *MockBuildClient) GetFileContents(ctx context.Context, args build.GetFileContentsArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFileContents", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFileContents indicates an expected call of GetFileContents
func (mr *MockBuildClientMockRecorder) GetFileContents(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileContents", reflect.TypeOf((*MockBuildClient)(nil).GetFileContents), ctx, args)
}

// CreateFolder mocks base method
func (m *MockBuildClient) CreateFolder(ctx context.Context, args build.CreateFolderArgs) (*build.Folder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFolder", ctx, args)
	ret0, _ := ret[0].(*build.Folder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFolder indicates an expected call of CreateFolder
func (mr *MockBuildClientMockRecorder) CreateFolder(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFolder", reflect.TypeOf((*MockBuildClient)(nil).CreateFolder), ctx, args)
}

// DeleteFolder mocks base method
func (m *MockBuildClient) DeleteFolder(ctx context.Context, args build.DeleteFolderArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFolder", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFolder indicates an expected call of DeleteFolder
func (mr *MockBuildClientMockRecorder) DeleteFolder(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFolder", reflect.TypeOf((*MockBuildClient)(nil).DeleteFolder), ctx, args)
}

// GetFolders mocks base method
func (m *MockBuildClient) GetFolders(ctx context.Context, args build.GetFoldersArgs) (*[]build.Folder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFolders", ctx, args)
	ret0, _ := ret[0].(*[]build.Folder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFolders indicates an expected call of GetFolders
func (mr *MockBuildClientMockRecorder) GetFolders(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFolders", reflect.TypeOf((*MockBuildClient)(nil).GetFolders), ctx, args)
}

// UpdateFolder mocks base method
func (m *MockBuildClient) UpdateFolder(ctx context.Context, args build.UpdateFolderArgs) (*build.Folder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFolder", ctx, args)
	ret0, _ := ret[0].(*build.Folder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateFolder indicates an expected call of UpdateFolder
func (mr *MockBuildClientMockRecorder) UpdateFolder(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFolder", reflect.TypeOf((*MockBuildClient)(nil).UpdateFolder), ctx, args)
}

// GetLatestBuild mocks base method
func (m *MockBuildClient) GetLatestBuild(ctx context.Context, args build.GetLatestBuildArgs) (*build.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestBuild", ctx, args)
	ret0, _ := ret[0].(*build.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestBuild indicates an expected call of GetLatestBuild
func (mr *MockBuildClientMockRecorder) GetLatestBuild(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestBuild", reflect.TypeOf((*MockBuildClient)(nil).GetLatestBuild), ctx, args)
}

// GetBuildLog mocks base method
func (m *MockBuildClient) GetBuildLog(ctx context.Context, args build.GetBuildLogArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildLog", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildLog indicates an expected call of GetBuildLog
func (mr *MockBuildClientMockRecorder) GetBuildLog(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLog", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLog), ctx, args)
}

// GetBuildLogLines mocks base method
func (m *MockBuildClient) GetBuildLogLines(ctx context.Context, args build.GetBuildLogLinesArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildLogLines", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildLogLines indicates an expected call of GetBuildLogLines
func (mr *MockBuildClientMockRecorder) GetBuildLogLines(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogLines", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogLines), ctx, args)
}

// GetBuildLogs mocks base method
func (m *MockBuildClient) GetBuildLogs(ctx context.Context, args build.GetBuildLogsArgs) (*[]build.BuildLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildLogs", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildLogs indicates an expected call of GetBuildLogs
func (mr *MockBuildClientMockRecorder) GetBuildLogs(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogs", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogs), ctx, args)
}

// GetBuildLogsZip mocks base method
func (m *MockBuildClient) GetBuildLogsZip(ctx context.Context, args build.GetBuildLogsZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildLogsZip", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildLogsZip indicates an expected call of GetBuildLogsZip
func (mr *MockBuildClientMockRecorder) GetBuildLogsZip(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogsZip", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogsZip), ctx, args)
}

// GetBuildLogZip mocks base method
func (m *MockBuildClient) GetBuildLogZip(ctx context.Context, args build.GetBuildLogZipArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildLogZip", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildLogZip indicates an expected call of GetBuildLogZip
func (mr *MockBuildClientMockRecorder) GetBuildLogZip(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildLogZip", reflect.TypeOf((*MockBuildClient)(nil).GetBuildLogZip), ctx, args)
}

// GetProjectMetrics mocks base method
func (m *MockBuildClient) GetProjectMetrics(ctx context.Context, args build.GetProjectMetricsArgs) (*[]build.BuildMetric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectMetrics", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildMetric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectMetrics indicates an expected call of GetProjectMetrics
func (mr *MockBuildClientMockRecorder) GetProjectMetrics(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectMetrics", reflect.TypeOf((*MockBuildClient)(nil).GetProjectMetrics), ctx, args)
}

// GetDefinitionMetrics mocks base method
func (m *MockBuildClient) GetDefinitionMetrics(ctx context.Context, args build.GetDefinitionMetricsArgs) (*[]build.BuildMetric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitionMetrics", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildMetric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitionMetrics indicates an expected call of GetDefinitionMetrics
func (mr *MockBuildClientMockRecorder) GetDefinitionMetrics(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionMetrics", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionMetrics), ctx, args)
}

// GetBuildOptionDefinitions mocks base method
func (m *MockBuildClient) GetBuildOptionDefinitions(ctx context.Context, args build.GetBuildOptionDefinitionsArgs) (*[]build.BuildOptionDefinition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildOptionDefinitions", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildOptionDefinition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildOptionDefinitions indicates an expected call of GetBuildOptionDefinitions
func (mr *MockBuildClientMockRecorder) GetBuildOptionDefinitions(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildOptionDefinitions", reflect.TypeOf((*MockBuildClient)(nil).GetBuildOptionDefinitions), ctx, args)
}

// GetPathContents mocks base method
func (m *MockBuildClient) GetPathContents(ctx context.Context, args build.GetPathContentsArgs) (*[]build.SourceRepositoryItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPathContents", ctx, args)
	ret0, _ := ret[0].(*[]build.SourceRepositoryItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPathContents indicates an expected call of GetPathContents
func (mr *MockBuildClientMockRecorder) GetPathContents(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPathContents", reflect.TypeOf((*MockBuildClient)(nil).GetPathContents), ctx, args)
}

// GetBuildProperties mocks base method
func (m *MockBuildClient) GetBuildProperties(ctx context.Context, args build.GetBuildPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildProperties", ctx, args)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildProperties indicates an expected call of GetBuildProperties
func (mr *MockBuildClientMockRecorder) GetBuildProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildProperties", reflect.TypeOf((*MockBuildClient)(nil).GetBuildProperties), ctx, args)
}

// UpdateBuildProperties mocks base method
func (m *MockBuildClient) UpdateBuildProperties(ctx context.Context, args build.UpdateBuildPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuildProperties", ctx, args)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBuildProperties indicates an expected call of UpdateBuildProperties
func (mr *MockBuildClientMockRecorder) UpdateBuildProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildProperties", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuildProperties), ctx, args)
}

// GetDefinitionProperties mocks base method
func (m *MockBuildClient) GetDefinitionProperties(ctx context.Context, args build.GetDefinitionPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitionProperties", ctx, args)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitionProperties indicates an expected call of GetDefinitionProperties
func (mr *MockBuildClientMockRecorder) GetDefinitionProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionProperties", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionProperties), ctx, args)
}

// UpdateDefinitionProperties mocks base method
func (m *MockBuildClient) UpdateDefinitionProperties(ctx context.Context, args build.UpdateDefinitionPropertiesArgs) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDefinitionProperties", ctx, args)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDefinitionProperties indicates an expected call of UpdateDefinitionProperties
func (mr *MockBuildClientMockRecorder) UpdateDefinitionProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDefinitionProperties", reflect.TypeOf((*MockBuildClient)(nil).UpdateDefinitionProperties), ctx, args)
}

// GetPullRequest mocks base method
func (m *MockBuildClient) GetPullRequest(ctx context.Context, args build.GetPullRequestArgs) (*build.PullRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequest", ctx, args)
	ret0, _ := ret[0].(*build.PullRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPullRequest indicates an expected call of GetPullRequest
func (mr *MockBuildClientMockRecorder) GetPullRequest(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockBuildClient)(nil).GetPullRequest), ctx, args)
}

// GetBuildReport mocks base method
func (m *MockBuildClient) GetBuildReport(ctx context.Context, args build.GetBuildReportArgs) (*build.BuildReportMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildReport", ctx, args)
	ret0, _ := ret[0].(*build.BuildReportMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildReport indicates an expected call of GetBuildReport
func (mr *MockBuildClientMockRecorder) GetBuildReport(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildReport", reflect.TypeOf((*MockBuildClient)(nil).GetBuildReport), ctx, args)
}

// GetBuildReportHtmlContent mocks base method
func (m *MockBuildClient) GetBuildReportHtmlContent(ctx context.Context, args build.GetBuildReportHtmlContentArgs) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildReportHtmlContent", ctx, args)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildReportHtmlContent indicates an expected call of GetBuildReportHtmlContent
func (mr *MockBuildClientMockRecorder) GetBuildReportHtmlContent(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildReportHtmlContent", reflect.TypeOf((*MockBuildClient)(nil).GetBuildReportHtmlContent), ctx, args)
}

// ListRepositories mocks base method
func (m *MockBuildClient) ListRepositories(ctx context.Context, args build.ListRepositoriesArgs) (*build.SourceRepositories, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRepositories", ctx, args)
	ret0, _ := ret[0].(*build.SourceRepositories)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRepositories indicates an expected call of ListRepositories
func (mr *MockBuildClientMockRecorder) ListRepositories(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositories", reflect.TypeOf((*MockBuildClient)(nil).ListRepositories), ctx, args)
}

// AuthorizeDefinitionResources mocks base method
func (m *MockBuildClient) AuthorizeDefinitionResources(ctx context.Context, args build.AuthorizeDefinitionResourcesArgs) (*[]build.DefinitionResourceReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeDefinitionResources", ctx, args)
	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeDefinitionResources indicates an expected call of AuthorizeDefinitionResources
func (mr *MockBuildClientMockRecorder) AuthorizeDefinitionResources(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeDefinitionResources", reflect.TypeOf((*MockBuildClient)(nil).AuthorizeDefinitionResources), ctx, args)
}

// GetDefinitionResources mocks base method
func (m *MockBuildClient) GetDefinitionResources(ctx context.Context, args build.GetDefinitionResourcesArgs) (*[]build.DefinitionResourceReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitionResources", ctx, args)
	ret0, _ := ret[0].(*[]build.DefinitionResourceReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitionResources indicates an expected call of GetDefinitionResources
func (mr *MockBuildClientMockRecorder) GetDefinitionResources(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionResources", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionResources), ctx, args)
}

// GetResourceUsage mocks base method
func (m *MockBuildClient) GetResourceUsage(ctx context.Context, args build.GetResourceUsageArgs) (*build.BuildResourceUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourceUsage", ctx, args)
	ret0, _ := ret[0].(*build.BuildResourceUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourceUsage indicates an expected call of GetResourceUsage
func (mr *MockBuildClientMockRecorder) GetResourceUsage(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceUsage", reflect.TypeOf((*MockBuildClient)(nil).GetResourceUsage), ctx, args)
}

// GetDefinitionRevisions mocks base method
func (m *MockBuildClient) GetDefinitionRevisions(ctx context.Context, args build.GetDefinitionRevisionsArgs) (*[]build.BuildDefinitionRevision, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitionRevisions", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildDefinitionRevision)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitionRevisions indicates an expected call of GetDefinitionRevisions
func (mr *MockBuildClientMockRecorder) GetDefinitionRevisions(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionRevisions", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionRevisions), ctx, args)
}

// GetBuildSettings mocks base method
func (m *MockBuildClient) GetBuildSettings(ctx context.Context, args build.GetBuildSettingsArgs) (*build.BuildSettings, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildSettings", ctx, args)
	ret0, _ := ret[0].(*build.BuildSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildSettings indicates an expected call of GetBuildSettings
func (mr *MockBuildClientMockRecorder) GetBuildSettings(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildSettings", reflect.TypeOf((*MockBuildClient)(nil).GetBuildSettings), ctx, args)
}

// UpdateBuildSettings mocks base method
func (m *MockBuildClient) UpdateBuildSettings(ctx context.Context, args build.UpdateBuildSettingsArgs) (*build.BuildSettings, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBuildSettings", ctx, args)
	ret0, _ := ret[0].(*build.BuildSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateBuildSettings indicates an expected call of UpdateBuildSettings
func (mr *MockBuildClientMockRecorder) UpdateBuildSettings(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBuildSettings", reflect.TypeOf((*MockBuildClient)(nil).UpdateBuildSettings), ctx, args)
}

// ListSourceProviders mocks base method
func (m *MockBuildClient) ListSourceProviders(ctx context.Context, args build.ListSourceProvidersArgs) (*[]build.SourceProviderAttributes, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSourceProviders", ctx, args)
	ret0, _ := ret[0].(*[]build.SourceProviderAttributes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSourceProviders indicates an expected call of ListSourceProviders
func (mr *MockBuildClientMockRecorder) ListSourceProviders(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSourceProviders", reflect.TypeOf((*MockBuildClient)(nil).ListSourceProviders), ctx, args)
}

// GetStatusBadge mocks base method
func (m *MockBuildClient) GetStatusBadge(ctx context.Context, args build.GetStatusBadgeArgs) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatusBadge", ctx, args)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatusBadge indicates an expected call of GetStatusBadge
func (mr *MockBuildClientMockRecorder) GetStatusBadge(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatusBadge", reflect.TypeOf((*MockBuildClient)(nil).GetStatusBadge), ctx, args)
}

// AddBuildTag mocks base method
func (m *MockBuildClient) AddBuildTag(ctx context.Context, args build.AddBuildTagArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBuildTag", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddBuildTag indicates an expected call of AddBuildTag
func (mr *MockBuildClientMockRecorder) AddBuildTag(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBuildTag", reflect.TypeOf((*MockBuildClient)(nil).AddBuildTag), ctx, args)
}

// AddBuildTags mocks base method
func (m *MockBuildClient) AddBuildTags(ctx context.Context, args build.AddBuildTagsArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBuildTags", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddBuildTags indicates an expected call of AddBuildTags
func (mr *MockBuildClientMockRecorder) AddBuildTags(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBuildTags", reflect.TypeOf((*MockBuildClient)(nil).AddBuildTags), ctx, args)
}

// DeleteBuildTag mocks base method
func (m *MockBuildClient) DeleteBuildTag(ctx context.Context, args build.DeleteBuildTagArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBuildTag", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBuildTag indicates an expected call of DeleteBuildTag
func (mr *MockBuildClientMockRecorder) DeleteBuildTag(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBuildTag", reflect.TypeOf((*MockBuildClient)(nil).DeleteBuildTag), ctx, args)
}

// GetBuildTags mocks base method
func (m *MockBuildClient) GetBuildTags(ctx context.Context, args build.GetBuildTagsArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildTags", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildTags indicates an expected call of GetBuildTags
func (mr *MockBuildClientMockRecorder) GetBuildTags(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildTags", reflect.TypeOf((*MockBuildClient)(nil).GetBuildTags), ctx, args)
}

// GetTags mocks base method
func (m *MockBuildClient) GetTags(ctx context.Context, args build.GetTagsArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTags", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTags indicates an expected call of GetTags
func (mr *MockBuildClientMockRecorder) GetTags(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTags", reflect.TypeOf((*MockBuildClient)(nil).GetTags), ctx, args)
}

// AddDefinitionTag mocks base method
func (m *MockBuildClient) AddDefinitionTag(ctx context.Context, args build.AddDefinitionTagArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddDefinitionTag", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddDefinitionTag indicates an expected call of AddDefinitionTag
func (mr *MockBuildClientMockRecorder) AddDefinitionTag(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDefinitionTag", reflect.TypeOf((*MockBuildClient)(nil).AddDefinitionTag), ctx, args)
}

// AddDefinitionTags mocks base method
func (m *MockBuildClient) AddDefinitionTags(ctx context.Context, args build.AddDefinitionTagsArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddDefinitionTags", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddDefinitionTags indicates an expected call of AddDefinitionTags
func (mr *MockBuildClientMockRecorder) AddDefinitionTags(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDefinitionTags", reflect.TypeOf((*MockBuildClient)(nil).AddDefinitionTags), ctx, args)
}

// DeleteDefinitionTag mocks base method
func (m *MockBuildClient) DeleteDefinitionTag(ctx context.Context, args build.DeleteDefinitionTagArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDefinitionTag", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDefinitionTag indicates an expected call of DeleteDefinitionTag
func (mr *MockBuildClientMockRecorder) DeleteDefinitionTag(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDefinitionTag", reflect.TypeOf((*MockBuildClient)(nil).DeleteDefinitionTag), ctx, args)
}

// GetDefinitionTags mocks base method
func (m *MockBuildClient) GetDefinitionTags(ctx context.Context, args build.GetDefinitionTagsArgs) (*[]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefinitionTags", ctx, args)
	ret0, _ := ret[0].(*[]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDefinitionTags indicates an expected call of GetDefinitionTags
func (mr *MockBuildClientMockRecorder) GetDefinitionTags(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefinitionTags", reflect.TypeOf((*MockBuildClient)(nil).GetDefinitionTags), ctx, args)
}

// DeleteTemplate mocks base method
func (m *MockBuildClient) DeleteTemplate(ctx context.Context, args build.DeleteTemplateArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplate", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTemplate indicates an expected call of DeleteTemplate
func (mr *MockBuildClientMockRecorder) DeleteTemplate(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTemplate", reflect.TypeOf((*MockBuildClient)(nil).DeleteTemplate), ctx, args)
}

// GetTemplate mocks base method
func (m *MockBuildClient) GetTemplate(ctx context.Context, args build.GetTemplateArgs) (*build.BuildDefinitionTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplate", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinitionTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplate indicates an expected call of GetTemplate
func (mr *MockBuildClientMockRecorder) GetTemplate(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplate", reflect.TypeOf((*MockBuildClient)(nil).GetTemplate), ctx, args)
}

// GetTemplates mocks base method
func (m *MockBuildClient) GetTemplates(ctx context.Context, args build.GetTemplatesArgs) (*[]build.BuildDefinitionTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplates", ctx, args)
	ret0, _ := ret[0].(*[]build.BuildDefinitionTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplates indicates an expected call of GetTemplates
func (mr *MockBuildClientMockRecorder) GetTemplates(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplates", reflect.TypeOf((*MockBuildClient)(nil).GetTemplates), ctx, args)
}

// SaveTemplate mocks base method
func (m *MockBuildClient) SaveTemplate(ctx context.Context, args build.SaveTemplateArgs) (*build.BuildDefinitionTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveTemplate", ctx, args)
	ret0, _ := ret[0].(*build.BuildDefinitionTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveTemplate indicates an expected call of SaveTemplate
func (mr *MockBuildClientMockRecorder) SaveTemplate(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTemplate", reflect.TypeOf((*MockBuildClient)(nil).SaveTemplate), ctx, args)
}

// GetBuildTimeline mocks base method
func (m *MockBuildClient) GetBuildTimeline(ctx context.Context, args build.GetBuildTimelineArgs) (*build.Timeline, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildTimeline", ctx, args)
	ret0, _ := ret[0].(*build.Timeline)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildTimeline indicates an expected call of GetBuildTimeline
func (mr *MockBuildClientMockRecorder) GetBuildTimeline(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildTimeline", reflect.TypeOf((*MockBuildClient)(nil).GetBuildTimeline), ctx, args)
}

// RestoreWebhooks mocks base method
func (m *MockBuildClient) RestoreWebhooks(ctx context.Context, args build.RestoreWebhooksArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreWebhooks", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestoreWebhooks indicates an expected call of RestoreWebhooks
func (mr *MockBuildClientMockRecorder) RestoreWebhooks(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreWebhooks", reflect.TypeOf((*MockBuildClient)(nil).RestoreWebhooks), ctx, args)
}

// ListWebhooks mocks base method
func (m *MockBuildClient) ListWebhooks(ctx context.Context, args build.ListWebhooksArgs) (*[]build.RepositoryWebhook, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWebhooks", ctx, args)
	ret0, _ := ret[0].(*[]build.RepositoryWebhook)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWebhooks indicates an expected call of ListWebhooks
func (mr *MockBuildClientMockRecorder) ListWebhooks(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWebhooks", reflect.TypeOf((*MockBuildClient)(nil).ListWebhooks), ctx, args)
}

// GetBuildWorkItemsRefs mocks base method
func (m *MockBuildClient) GetBuildWorkItemsRefs(ctx context.Context, args build.GetBuildWorkItemsRefsArgs) (*[]webapi.ResourceRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildWorkItemsRefs", ctx, args)
	ret0, _ := ret[0].(*[]webapi.ResourceRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildWorkItemsRefs indicates an expected call of GetBuildWorkItemsRefs
func (mr *MockBuildClientMockRecorder) GetBuildWorkItemsRefs(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildWorkItemsRefs", reflect.TypeOf((*MockBuildClient)(nil).GetBuildWorkItemsRefs), ctx, args)
}

// GetBuildWorkItemsRefsFromCommits mocks base method
func (m *MockBuildClient) GetBuildWorkItemsRefsFromCommits(ctx context.Context, args build.GetBuildWorkItemsRefsFromCommitsArgs) (*[]webapi.ResourceRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildWorkItemsRefsFromCommits", ctx, args)
	ret0, _ := ret[0].(*[]webapi.ResourceRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuildWorkItemsRefsFromCommits indicates an expected call of GetBuildWorkItemsRefsFromCommits
func (mr *MockBuildClientMockRecorder) GetBuildWorkItemsRefsFromCommits(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuildWorkItemsRefsFromCommits", reflect.TypeOf((*MockBuildClient)(nil).GetBuildWorkItemsRefsFromCommits), ctx, args)
}

// GetWorkItemsBetweenBuilds mocks base method
func (m *MockBuildClient) GetWorkItemsBetweenBuilds(ctx context.Context, args build.GetWorkItemsBetweenBuildsArgs) (*[]webapi.ResourceRef, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkItemsBetweenBuilds", ctx, args)
	ret0, _ := ret[0].(*[]webapi.ResourceRef)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkItemsBetweenBuilds indicates an expected call of GetWorkItemsBetweenBuilds
func (mr *MockBuildClientMockRecorder) GetWorkItemsBetweenBuilds(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkItemsBetweenBuilds", reflect.TypeOf((*MockBuildClient)(nil).GetWorkItemsBetweenBuilds), ctx, args)
}

// MockCoreClient is a mock of CoreClient interface
type MockCoreClient struct {
	ctrl     *gomock.Controller
	recorder *MockCoreClientMockRecorder
}

// MockCoreClientMockRecorder is the mock recorder for MockCoreClient
type MockCoreClientMockRecorder struct {
	mock *MockCoreClient
}

// NewMockCoreClient creates a new mock instance
func NewMockCoreClient(ctrl *gomock.Controller) *MockCoreClient {
	mock := &MockCoreClient{ctrl: ctrl}
	mock.recorder = &MockCoreClientMockRecorder{mock}
	return mock
}

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

// RemoveProjectAvatar mocks base method
func (m *MockCoreClient) RemoveProjectAvatar(ctx context.Context, args core.RemoveProjectAvatarArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveProjectAvatar", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveProjectAvatar indicates an expected call of RemoveProjectAvatar
func (mr *MockCoreClientMockRecorder) RemoveProjectAvatar(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectAvatar", reflect.TypeOf((*MockCoreClient)(nil).RemoveProjectAvatar), ctx, args)
}

// SetProjectAvatar mocks base method
func (m *MockCoreClient) SetProjectAvatar(ctx context.Context, args core.SetProjectAvatarArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProjectAvatar", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetProjectAvatar indicates an expected call of SetProjectAvatar
func (mr *MockCoreClientMockRecorder) SetProjectAvatar(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProjectAvatar", reflect.TypeOf((*MockCoreClient)(nil).SetProjectAvatar), ctx, args)
}

// CreateConnectedService mocks base method
func (m *MockCoreClient) CreateConnectedService(ctx context.Context, args core.CreateConnectedServiceArgs) (*core.WebApiConnectedService, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConnectedService", ctx, args)
	ret0, _ := ret[0].(*core.WebApiConnectedService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConnectedService indicates an expected call of CreateConnectedService
func (mr *MockCoreClientMockRecorder) CreateConnectedService(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnectedService", reflect.TypeOf((*MockCoreClient)(nil).CreateConnectedService), ctx, args)
}

// GetConnectedServiceDetails mocks base method
func (m *MockCoreClient) GetConnectedServiceDetails(ctx context.Context, args core.GetConnectedServiceDetailsArgs) (*core.WebApiConnectedServiceDetails, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectedServiceDetails", ctx, args)
	ret0, _ := ret[0].(*core.WebApiConnectedServiceDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnectedServiceDetails indicates an expected call of GetConnectedServiceDetails
func (mr *MockCoreClientMockRecorder) GetConnectedServiceDetails(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectedServiceDetails", reflect.TypeOf((*MockCoreClient)(nil).GetConnectedServiceDetails), ctx, args)
}

// GetConnectedServices mocks base method
func (m *MockCoreClient) GetConnectedServices(ctx context.Context, args core.GetConnectedServicesArgs) (*[]core.WebApiConnectedService, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectedServices", ctx, args)
	ret0, _ := ret[0].(*[]core.WebApiConnectedService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnectedServices indicates an expected call of GetConnectedServices
func (mr *MockCoreClientMockRecorder) GetConnectedServices(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectedServices", reflect.TypeOf((*MockCoreClient)(nil).GetConnectedServices), ctx, args)
}

// GetTeamMembersWithExtendedProperties mocks base method
func (m *MockCoreClient) GetTeamMembersWithExtendedProperties(ctx context.Context, args core.GetTeamMembersWithExtendedPropertiesArgs) (*[]webapi.TeamMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeamMembersWithExtendedProperties", ctx, args)
	ret0, _ := ret[0].(*[]webapi.TeamMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamMembersWithExtendedProperties indicates an expected call of GetTeamMembersWithExtendedProperties
func (mr *MockCoreClientMockRecorder) GetTeamMembersWithExtendedProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamMembersWithExtendedProperties", reflect.TypeOf((*MockCoreClient)(nil).GetTeamMembersWithExtendedProperties), ctx, args)
}

// GetProcessById mocks base method
func (m *MockCoreClient) GetProcessById(ctx context.Context, args core.GetProcessByIdArgs) (*core.Process, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProcessById", ctx, args)
	ret0, _ := ret[0].(*core.Process)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProcessById indicates an expected call of GetProcessById
func (mr *MockCoreClientMockRecorder) GetProcessById(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcessById", reflect.TypeOf((*MockCoreClient)(nil).GetProcessById), ctx, args)
}

// GetProcesses mocks base method
func (m *MockCoreClient) GetProcesses(ctx context.Context, args core.GetProcessesArgs) (*[]core.Process, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProcesses", ctx, args)
	ret0, _ := ret[0].(*[]core.Process)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProcesses indicates an expected call of GetProcesses
func (mr *MockCoreClientMockRecorder) GetProcesses(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProcesses", reflect.TypeOf((*MockCoreClient)(nil).GetProcesses), ctx, args)
}

// GetProjectCollection mocks base method
func (m *MockCoreClient) GetProjectCollection(ctx context.Context, args core.GetProjectCollectionArgs) (*core.TeamProjectCollection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectCollection", ctx, args)
	ret0, _ := ret[0].(*core.TeamProjectCollection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectCollection indicates an expected call of GetProjectCollection
func (mr *MockCoreClientMockRecorder) GetProjectCollection(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCollection", reflect.TypeOf((*MockCoreClient)(nil).GetProjectCollection), ctx, args)
}

// GetProjectCollections mocks base method
func (m *MockCoreClient) GetProjectCollections(ctx context.Context, args core.GetProjectCollectionsArgs) (*[]core.TeamProjectCollectionReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectCollections", ctx, args)
	ret0, _ := ret[0].(*[]core.TeamProjectCollectionReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectCollections indicates an expected call of GetProjectCollections
func (mr *MockCoreClientMockRecorder) GetProjectCollections(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectCollections", reflect.TypeOf((*MockCoreClient)(nil).GetProjectCollections), ctx, args)
}

// GetProject mocks base method
func (m *MockCoreClient) GetProject(ctx context.Context, args core.GetProjectArgs) (*core.TeamProject, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProject", ctx, args)
	ret0, _ := ret[0].(*core.TeamProject)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProject indicates an expected call of GetProject
func (mr *MockCoreClientMockRecorder) GetProject(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProject", reflect.TypeOf((*MockCoreClient)(nil).GetProject), ctx, args)
}

// GetProjects mocks base method
func (m *MockCoreClient) GetProjects(ctx context.Context, args core.GetProjectsArgs) (*core.GetProjectsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjects", ctx, args)
	ret0, _ := ret[0].(*core.GetProjectsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjects indicates an expected call of GetProjects
func (mr *MockCoreClientMockRecorder) GetProjects(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjects", reflect.TypeOf((*MockCoreClient)(nil).GetProjects), ctx, args)
}

// QueueCreateProject mocks base method
func (m *MockCoreClient) QueueCreateProject(ctx context.Context, args core.QueueCreateProjectArgs) (*operations.OperationReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueueCreateProject", ctx, args)
	ret0, _ := ret[0].(*operations.OperationReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueueCreateProject indicates an expected call of QueueCreateProject
func (mr *MockCoreClientMockRecorder) QueueCreateProject(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueCreateProject", reflect.TypeOf((*MockCoreClient)(nil).QueueCreateProject), ctx, args)
}

// QueueDeleteProject mocks base method
func (m *MockCoreClient) QueueDeleteProject(ctx context.Context, args core.QueueDeleteProjectArgs) (*operations.OperationReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueueDeleteProject", ctx, args)
	ret0, _ := ret[0].(*operations.OperationReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueueDeleteProject indicates an expected call of QueueDeleteProject
func (mr *MockCoreClientMockRecorder) QueueDeleteProject(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueDeleteProject", reflect.TypeOf((*MockCoreClient)(nil).QueueDeleteProject), ctx, args)
}

// UpdateProject mocks base method
func (m *MockCoreClient) UpdateProject(ctx context.Context, args core.UpdateProjectArgs) (*operations.OperationReference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProject", ctx, args)
	ret0, _ := ret[0].(*operations.OperationReference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProject indicates an expected call of UpdateProject
func (mr *MockCoreClientMockRecorder) UpdateProject(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockCoreClient)(nil).UpdateProject), ctx, args)
}

// GetProjectProperties mocks base method
func (m *MockCoreClient) GetProjectProperties(ctx context.Context, args core.GetProjectPropertiesArgs) (*[]core.ProjectProperty, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectProperties", ctx, args)
	ret0, _ := ret[0].(*[]core.ProjectProperty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectProperties indicates an expected call of GetProjectProperties
func (mr *MockCoreClientMockRecorder) GetProjectProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectProperties", reflect.TypeOf((*MockCoreClient)(nil).GetProjectProperties), ctx, args)
}

// SetProjectProperties mocks base method
func (m *MockCoreClient) SetProjectProperties(ctx context.Context, args core.SetProjectPropertiesArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProjectProperties", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetProjectProperties indicates an expected call of SetProjectProperties
func (mr *MockCoreClientMockRecorder) SetProjectProperties(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProjectProperties", reflect.TypeOf((*MockCoreClient)(nil).SetProjectProperties), ctx, args)
}

// CreateOrUpdateProxy mocks base method
func (m *MockCoreClient) CreateOrUpdateProxy(ctx context.Context, args core.CreateOrUpdateProxyArgs) (*core.Proxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrUpdateProxy", ctx, args)
	ret0, _ := ret[0].(*core.Proxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOrUpdateProxy indicates an expected call of CreateOrUpdateProxy
func (mr *MockCoreClientMockRecorder) CreateOrUpdateProxy(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateProxy", reflect.TypeOf((*MockCoreClient)(nil).CreateOrUpdateProxy), ctx, args)
}

// DeleteProxy mocks base method
func (m *MockCoreClient) DeleteProxy(ctx context.Context, args core.DeleteProxyArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProxy", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProxy indicates an expected call of DeleteProxy
func (mr *MockCoreClientMockRecorder) DeleteProxy(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProxy", reflect.TypeOf((*MockCoreClient)(nil).DeleteProxy), ctx, args)
}

// GetProxies mocks base method
func (m *MockCoreClient) GetProxies(ctx context.Context, args core.GetProxiesArgs) (*[]core.Proxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProxies", ctx, args)
	ret0, _ := ret[0].(*[]core.Proxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProxies indicates an expected call of GetProxies
func (mr *MockCoreClientMockRecorder) GetProxies(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProxies", reflect.TypeOf((*MockCoreClient)(nil).GetProxies), ctx, args)
}

// CreateTeam mocks base method
func (m *MockCoreClient) CreateTeam(ctx context.Context, args core.CreateTeamArgs) (*core.WebApiTeam, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTeam", ctx, args)
	ret0, _ := ret[0].(*core.WebApiTeam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTeam indicates an expected call of CreateTeam
func (mr *MockCoreClientMockRecorder) CreateTeam(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTeam", reflect.TypeOf((*MockCoreClient)(nil).CreateTeam), ctx, args)
}

// DeleteTeam mocks base method
func (m *MockCoreClient) DeleteTeam(ctx context.Context, args core.DeleteTeamArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTeam", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTeam indicates an expected call of DeleteTeam
func (mr *MockCoreClientMockRecorder) DeleteTeam(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeam", reflect.TypeOf((*MockCoreClient)(nil).DeleteTeam), ctx, args)
}

// GetTeam mocks base method
func (m *MockCoreClient) GetTeam(ctx context.Context, args core.GetTeamArgs) (*core.WebApiTeam, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeam", ctx, args)
	ret0, _ := ret[0].(*core.WebApiTeam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeam indicates an expected call of GetTeam
func (mr *MockCoreClientMockRecorder) GetTeam(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeam", reflect.TypeOf((*MockCoreClient)(nil).GetTeam), ctx, args)
}

// GetTeams mocks base method
func (m *MockCoreClient) GetTeams(ctx context.Context, args core.GetTeamsArgs) (*[]core.WebApiTeam, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTeams", ctx, args)
	ret0, _ := ret[0].(*[]core.WebApiTeam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeams indicates an expected call of GetTeams
func (mr *MockCoreClientMockRecorder) GetTeams(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeams", reflect.TypeOf((*MockCoreClient)(nil).GetTeams), ctx, args)
}

// UpdateTeam mocks base method
func (m *MockCoreClient) UpdateTeam(ctx context.Context, args core.UpdateTeamArgs) (*core.WebApiTeam, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTeam", ctx, args)
	ret0, _ := ret[0].(*core.WebApiTeam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTeam indicates an expected call of UpdateTeam
func (mr *MockCoreClientMockRecorder) UpdateTeam(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTeam", reflect.TypeOf((*MockCoreClient)(nil).UpdateTeam), ctx, args)
}

// GetAllTeams mocks base method
func (m *MockCoreClient) GetAllTeams(ctx context.Context, args core.GetAllTeamsArgs) (*[]core.WebApiTeam, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllTeams", ctx, args)
	ret0, _ := ret[0].(*[]core.WebApiTeam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllTeams indicates an expected call of GetAllTeams
func (mr *MockCoreClientMockRecorder) GetAllTeams(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTeams", reflect.TypeOf((*MockCoreClient)(nil).GetAllTeams), ctx, args)
}

// MockOperationsClient is a mock of OperationsClient interface
type MockOperationsClient struct {
	ctrl     *gomock.Controller
	recorder *MockOperationsClientMockRecorder
}

// MockOperationsClientMockRecorder is the mock recorder for MockOperationsClient
type MockOperationsClientMockRecorder struct {
	mock *MockOperationsClient
}

// NewMockOperationsClient creates a new mock instance
func NewMockOperationsClient(ctrl *gomock.Controller) *MockOperationsClient {
	mock := &MockOperationsClient{ctrl: ctrl}
	mock.recorder = &MockOperationsClientMockRecorder{mock}
	return mock
}

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

// GetOperation mocks base method
func (m *MockOperationsClient) GetOperation(ctx context.Context, args operations.GetOperationArgs) (*operations.Operation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOperation", ctx, args)
	ret0, _ := ret[0].(*operations.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperation indicates an expected call of GetOperation
func (mr *MockOperationsClientMockRecorder) GetOperation(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockOperationsClient)(nil).GetOperation), ctx, args)
}

// MockServiceEndpointClient is a mock of ServiceEndpointClient interface
type MockServiceEndpointClient struct {
	ctrl     *gomock.Controller
	recorder *MockServiceEndpointClientMockRecorder
}

// MockServiceEndpointClientMockRecorder is the mock recorder for MockServiceEndpointClient
type MockServiceEndpointClientMockRecorder struct {
	mock *MockServiceEndpointClient
}

// NewMockServiceEndpointClient creates a new mock instance
func NewMockServiceEndpointClient(ctrl *gomock.Controller) *MockServiceEndpointClient {
	mock := &MockServiceEndpointClient{ctrl: ctrl}
	mock.recorder = &MockServiceEndpointClientMockRecorder{mock}
	return mock
}

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

// ExecuteServiceEndpointRequest mocks base method
func (m *MockServiceEndpointClient) ExecuteServiceEndpointRequest(ctx context.Context, args serviceendpoint.ExecuteServiceEndpointRequestArgs) (*serviceendpoint.ServiceEndpointRequestResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteServiceEndpointRequest", ctx, args)
	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpointRequestResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteServiceEndpointRequest indicates an expected call of ExecuteServiceEndpointRequest
func (mr *MockServiceEndpointClientMockRecorder) ExecuteServiceEndpointRequest(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteServiceEndpointRequest", reflect.TypeOf((*MockServiceEndpointClient)(nil).ExecuteServiceEndpointRequest), ctx, args)
}

// CreateServiceEndpoint mocks base method
func (m *MockServiceEndpointClient) CreateServiceEndpoint(ctx context.Context, args serviceendpoint.CreateServiceEndpointArgs) (*serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServiceEndpoint", ctx, args)
	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServiceEndpoint indicates an expected call of CreateServiceEndpoint
func (mr *MockServiceEndpointClientMockRecorder) CreateServiceEndpoint(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceEndpoint", reflect.TypeOf((*MockServiceEndpointClient)(nil).CreateServiceEndpoint), ctx, args)
}

// DeleteServiceEndpoint mocks base method
func (m *MockServiceEndpointClient) DeleteServiceEndpoint(ctx context.Context, args serviceendpoint.DeleteServiceEndpointArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServiceEndpoint", ctx, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServiceEndpoint indicates an expected call of DeleteServiceEndpoint
func (mr *MockServiceEndpointClientMockRecorder) DeleteServiceEndpoint(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceEndpoint", reflect.TypeOf((*MockServiceEndpointClient)(nil).DeleteServiceEndpoint), ctx, args)
}

// GetServiceEndpointDetails mocks base method
func (m *MockServiceEndpointClient) GetServiceEndpointDetails(ctx context.Context, args serviceendpoint.GetServiceEndpointDetailsArgs) (*serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpointDetails", ctx, args)
	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpointDetails indicates an expected call of GetServiceEndpointDetails
func (mr *MockServiceEndpointClientMockRecorder) GetServiceEndpointDetails(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointDetails", reflect.TypeOf((*MockServiceEndpointClient)(nil).GetServiceEndpointDetails), ctx, args)
}

// GetServiceEndpoints mocks base method
func (m *MockServiceEndpointClient) GetServiceEndpoints(ctx context.Context, args serviceendpoint.GetServiceEndpointsArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpoints", ctx, args)
	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpoints indicates an expected call of GetServiceEndpoints
func (mr *MockServiceEndpointClientMockRecorder) GetServiceEndpoints(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpoints", reflect.TypeOf((*MockServiceEndpointClient)(nil).GetServiceEndpoints), ctx, args)
}

// GetServiceEndpointsByNames mocks base method
func (m *MockServiceEndpointClient) GetServiceEndpointsByNames(ctx context.Context, args serviceendpoint.GetServiceEndpointsByNamesArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpointsByNames", ctx, args)
	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpointsByNames indicates an expected call of GetServiceEndpointsByNames
func (mr *MockServiceEndpointClientMockRecorder) GetServiceEndpointsByNames(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointsByNames", reflect.TypeOf((*MockServiceEndpointClient)(nil).GetServiceEndpointsByNames), ctx, args)
}

// UpdateServiceEndpoint mocks base method
func (m *MockServiceEndpointClient) UpdateServiceEndpoint(ctx context.Context, args serviceendpoint.UpdateServiceEndpointArgs) (*serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceEndpoint", ctx, args)
	ret0, _ := ret[0].(*serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceEndpoint indicates an expected call of UpdateServiceEndpoint
func (mr *MockServiceEndpointClientMockRecorder) UpdateServiceEndpoint(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceEndpoint", reflect.TypeOf((*MockServiceEndpointClient)(nil).UpdateServiceEndpoint), ctx, args)
}

// UpdateServiceEndpoints mocks base method
func (m *MockServiceEndpointClient) UpdateServiceEndpoints(ctx context.Context, args serviceendpoint.UpdateServiceEndpointsArgs) (*[]serviceendpoint.ServiceEndpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceEndpoints", ctx, args)
	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceEndpoints indicates an expected call of UpdateServiceEndpoints
func (mr *MockServiceEndpointClientMockRecorder) UpdateServiceEndpoints(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceEndpoints", reflect.TypeOf((*MockServiceEndpointClient)(nil).UpdateServiceEndpoints), ctx, args)
}

// GetServiceEndpointExecutionRecords mocks base method
func (m *MockServiceEndpointClient) GetServiceEndpointExecutionRecords(ctx context.Context, args serviceendpoint.GetServiceEndpointExecutionRecordsArgs) (*serviceendpoint.GetServiceEndpointExecutionRecordsResponseValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpointExecutionRecords", ctx, args)
	ret0, _ := ret[0].(*serviceendpoint.GetServiceEndpointExecutionRecordsResponseValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpointExecutionRecords indicates an expected call of GetServiceEndpointExecutionRecords
func (mr *MockServiceEndpointClientMockRecorder) GetServiceEndpointExecutionRecords(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointExecutionRecords", reflect.TypeOf((*MockServiceEndpointClient)(nil).GetServiceEndpointExecutionRecords), ctx, args)
}

// GetServiceEndpointTypes mocks base method
func (m *MockServiceEndpointClient) GetServiceEndpointTypes(ctx context.Context, args serviceendpoint.GetServiceEndpointTypesArgs) (*[]serviceendpoint.ServiceEndpointType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpointTypes", ctx, args)
	ret0, _ := ret[0].(*[]serviceendpoint.ServiceEndpointType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpointTypes indicates an expected call of GetServiceEndpointTypes
func (mr *MockServiceEndpointClientMockRecorder) GetServiceEndpointTypes(ctx, args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpointTypes", reflect.TypeOf((*MockServiceEndpointClient)(nil).GetServiceEndpointTypes), ctx, args)
}