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

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

import (
	context "context"
	io "io"
	http "net/http"
	url "net/url"
	os "os"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	github "github.com/google/go-github/v43/github"
)

// MockRepositories is a mock of Repositories interface.
type MockRepositories struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoriesMockRecorder
}

// MockRepositoriesMockRecorder is the mock recorder for MockRepositories.
type MockRepositoriesMockRecorder struct {
	mock *MockRepositories
}

// NewMockRepositories creates a new mock instance.
func NewMockRepositories(ctrl *gomock.Controller) *MockRepositories {
	mock := &MockRepositories{ctrl: ctrl}
	mock.recorder = &MockRepositoriesMockRecorder{mock}
	return mock
}

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

// AddAdminEnforcement mocks base method.
func (m *MockRepositories) AddAdminEnforcement(arg0 context.Context, arg1, arg2, arg3 string) (*github.AdminEnforcement, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAdminEnforcement", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.AdminEnforcement)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddAdminEnforcement indicates an expected call of AddAdminEnforcement.
func (mr *MockRepositoriesMockRecorder) AddAdminEnforcement(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAdminEnforcement", reflect.TypeOf((*MockRepositories)(nil).AddAdminEnforcement), arg0, arg1, arg2, arg3)
}

// AddAppRestrictions mocks base method.
func (m *MockRepositories) AddAppRestrictions(arg0 context.Context, arg1, arg2, arg3 string, arg4 []string) ([]*github.App, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAppRestrictions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.App)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddAppRestrictions indicates an expected call of AddAppRestrictions.
func (mr *MockRepositoriesMockRecorder) AddAppRestrictions(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAppRestrictions", reflect.TypeOf((*MockRepositories)(nil).AddAppRestrictions), arg0, arg1, arg2, arg3, arg4)
}

// AddCollaborator mocks base method.
func (m *MockRepositories) AddCollaborator(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryAddCollaboratorOptions) (*github.CollaboratorInvitation, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddCollaborator", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.CollaboratorInvitation)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddCollaborator indicates an expected call of AddCollaborator.
func (mr *MockRepositoriesMockRecorder) AddCollaborator(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCollaborator", reflect.TypeOf((*MockRepositories)(nil).AddCollaborator), arg0, arg1, arg2, arg3, arg4)
}

// CompareCommits mocks base method.
func (m *MockRepositories) CompareCommits(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 *github.ListOptions) (*github.CommitsComparison, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareCommits", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*github.CommitsComparison)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CompareCommits indicates an expected call of CompareCommits.
func (mr *MockRepositoriesMockRecorder) CompareCommits(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareCommits", reflect.TypeOf((*MockRepositories)(nil).CompareCommits), arg0, arg1, arg2, arg3, arg4, arg5)
}

// CompareCommitsRaw mocks base method.
func (m *MockRepositories) CompareCommitsRaw(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 github.RawOptions) (string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareCommitsRaw", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CompareCommitsRaw indicates an expected call of CompareCommitsRaw.
func (mr *MockRepositoriesMockRecorder) CompareCommitsRaw(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareCommitsRaw", reflect.TypeOf((*MockRepositories)(nil).CompareCommitsRaw), arg0, arg1, arg2, arg3, arg4, arg5)
}

// Create mocks base method.
func (m *MockRepositories) Create(arg0 context.Context, arg1 string, arg2 *github.Repository) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockRepositoriesMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRepositories)(nil).Create), arg0, arg1, arg2)
}

// CreateComment mocks base method.
func (m *MockRepositories) CreateComment(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryComment) (*github.RepositoryComment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateComment", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryComment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateComment indicates an expected call of CreateComment.
func (mr *MockRepositoriesMockRecorder) CreateComment(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateComment", reflect.TypeOf((*MockRepositories)(nil).CreateComment), arg0, arg1, arg2, arg3, arg4)
}

// CreateDeployment mocks base method.
func (m *MockRepositories) CreateDeployment(arg0 context.Context, arg1, arg2 string, arg3 *github.DeploymentRequest) (*github.Deployment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeployment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Deployment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateDeployment indicates an expected call of CreateDeployment.
func (mr *MockRepositoriesMockRecorder) CreateDeployment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeployment", reflect.TypeOf((*MockRepositories)(nil).CreateDeployment), arg0, arg1, arg2, arg3)
}

// CreateDeploymentStatus mocks base method.
func (m *MockRepositories) CreateDeploymentStatus(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.DeploymentStatusRequest) (*github.DeploymentStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeploymentStatus", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.DeploymentStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateDeploymentStatus indicates an expected call of CreateDeploymentStatus.
func (mr *MockRepositoriesMockRecorder) CreateDeploymentStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeploymentStatus", reflect.TypeOf((*MockRepositories)(nil).CreateDeploymentStatus), arg0, arg1, arg2, arg3, arg4)
}

// CreateFile mocks base method.
func (m *MockRepositories) CreateFile(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentFileOptions) (*github.RepositoryContentResponse, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFile", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryContentResponse)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFile indicates an expected call of CreateFile.
func (mr *MockRepositoriesMockRecorder) CreateFile(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFile", reflect.TypeOf((*MockRepositories)(nil).CreateFile), arg0, arg1, arg2, arg3, arg4)
}

// CreateFork mocks base method.
func (m *MockRepositories) CreateFork(arg0 context.Context, arg1, arg2 string, arg3 *github.RepositoryCreateForkOptions) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFork", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFork indicates an expected call of CreateFork.
func (mr *MockRepositoriesMockRecorder) CreateFork(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFork", reflect.TypeOf((*MockRepositories)(nil).CreateFork), arg0, arg1, arg2, arg3)
}

// CreateFromTemplate mocks base method.
func (m *MockRepositories) CreateFromTemplate(arg0 context.Context, arg1, arg2 string, arg3 *github.TemplateRepoRequest) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFromTemplate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateFromTemplate indicates an expected call of CreateFromTemplate.
func (mr *MockRepositoriesMockRecorder) CreateFromTemplate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFromTemplate", reflect.TypeOf((*MockRepositories)(nil).CreateFromTemplate), arg0, arg1, arg2, arg3)
}

// CreateHook mocks base method.
func (m *MockRepositories) CreateHook(arg0 context.Context, arg1, arg2 string, arg3 *github.Hook) (*github.Hook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Hook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateHook indicates an expected call of CreateHook.
func (mr *MockRepositoriesMockRecorder) CreateHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHook", reflect.TypeOf((*MockRepositories)(nil).CreateHook), arg0, arg1, arg2, arg3)
}

// CreateKey mocks base method.
func (m *MockRepositories) CreateKey(arg0 context.Context, arg1, arg2 string, arg3 *github.Key) (*github.Key, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKey", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Key)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateKey indicates an expected call of CreateKey.
func (mr *MockRepositoriesMockRecorder) CreateKey(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKey", reflect.TypeOf((*MockRepositories)(nil).CreateKey), arg0, arg1, arg2, arg3)
}

// CreateProject mocks base method.
func (m *MockRepositories) CreateProject(arg0 context.Context, arg1, arg2 string, arg3 *github.ProjectOptions) (*github.Project, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProject", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Project)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateProject indicates an expected call of CreateProject.
func (mr *MockRepositoriesMockRecorder) CreateProject(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockRepositories)(nil).CreateProject), arg0, arg1, arg2, arg3)
}

// CreateRelease mocks base method.
func (m *MockRepositories) CreateRelease(arg0 context.Context, arg1, arg2 string, arg3 *github.RepositoryRelease) (*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRelease", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateRelease indicates an expected call of CreateRelease.
func (mr *MockRepositoriesMockRecorder) CreateRelease(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRelease", reflect.TypeOf((*MockRepositories)(nil).CreateRelease), arg0, arg1, arg2, arg3)
}

// CreateStatus mocks base method.
func (m *MockRepositories) CreateStatus(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepoStatus) (*github.RepoStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStatus", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepoStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateStatus indicates an expected call of CreateStatus.
func (mr *MockRepositoriesMockRecorder) CreateStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStatus", reflect.TypeOf((*MockRepositories)(nil).CreateStatus), arg0, arg1, arg2, arg3, arg4)
}

// CreateUpdateEnvironment mocks base method.
func (m *MockRepositories) CreateUpdateEnvironment(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.CreateUpdateEnvironment) (*github.Environment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUpdateEnvironment", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.Environment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateUpdateEnvironment indicates an expected call of CreateUpdateEnvironment.
func (mr *MockRepositoriesMockRecorder) CreateUpdateEnvironment(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUpdateEnvironment", reflect.TypeOf((*MockRepositories)(nil).CreateUpdateEnvironment), arg0, arg1, arg2, arg3, arg4)
}

// Delete mocks base method.
func (m *MockRepositories) Delete(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockRepositoriesMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepositories)(nil).Delete), arg0, arg1, arg2)
}

// DeleteComment mocks base method.
func (m *MockRepositories) DeleteComment(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteComment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteComment indicates an expected call of DeleteComment.
func (mr *MockRepositoriesMockRecorder) DeleteComment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteComment", reflect.TypeOf((*MockRepositories)(nil).DeleteComment), arg0, arg1, arg2, arg3)
}

// DeleteDeployment mocks base method.
func (m *MockRepositories) DeleteDeployment(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDeployment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDeployment indicates an expected call of DeleteDeployment.
func (mr *MockRepositoriesMockRecorder) DeleteDeployment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeployment", reflect.TypeOf((*MockRepositories)(nil).DeleteDeployment), arg0, arg1, arg2, arg3)
}

// DeleteEnvironment mocks base method.
func (m *MockRepositories) DeleteEnvironment(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEnvironment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteEnvironment indicates an expected call of DeleteEnvironment.
func (mr *MockRepositoriesMockRecorder) DeleteEnvironment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEnvironment", reflect.TypeOf((*MockRepositories)(nil).DeleteEnvironment), arg0, arg1, arg2, arg3)
}

// DeleteFile mocks base method.
func (m *MockRepositories) DeleteFile(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentFileOptions) (*github.RepositoryContentResponse, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFile", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryContentResponse)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteFile indicates an expected call of DeleteFile.
func (mr *MockRepositoriesMockRecorder) DeleteFile(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFile", reflect.TypeOf((*MockRepositories)(nil).DeleteFile), arg0, arg1, arg2, arg3, arg4)
}

// DeleteHook mocks base method.
func (m *MockRepositories) DeleteHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteHook indicates an expected call of DeleteHook.
func (mr *MockRepositoriesMockRecorder) DeleteHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHook", reflect.TypeOf((*MockRepositories)(nil).DeleteHook), arg0, arg1, arg2, arg3)
}

// DeleteInvitation mocks base method.
func (m *MockRepositories) DeleteInvitation(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInvitation", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInvitation indicates an expected call of DeleteInvitation.
func (mr *MockRepositoriesMockRecorder) DeleteInvitation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInvitation", reflect.TypeOf((*MockRepositories)(nil).DeleteInvitation), arg0, arg1, arg2, arg3)
}

// DeleteKey mocks base method.
func (m *MockRepositories) DeleteKey(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKey", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteKey indicates an expected call of DeleteKey.
func (mr *MockRepositoriesMockRecorder) DeleteKey(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKey", reflect.TypeOf((*MockRepositories)(nil).DeleteKey), arg0, arg1, arg2, arg3)
}

// DeletePreReceiveHook mocks base method.
func (m *MockRepositories) DeletePreReceiveHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePreReceiveHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePreReceiveHook indicates an expected call of DeletePreReceiveHook.
func (mr *MockRepositoriesMockRecorder) DeletePreReceiveHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePreReceiveHook", reflect.TypeOf((*MockRepositories)(nil).DeletePreReceiveHook), arg0, arg1, arg2, arg3)
}

// DeleteRelease mocks base method.
func (m *MockRepositories) DeleteRelease(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRelease", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRelease indicates an expected call of DeleteRelease.
func (mr *MockRepositoriesMockRecorder) DeleteRelease(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRelease", reflect.TypeOf((*MockRepositories)(nil).DeleteRelease), arg0, arg1, arg2, arg3)
}

// DeleteReleaseAsset mocks base method.
func (m *MockRepositories) DeleteReleaseAsset(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReleaseAsset", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReleaseAsset indicates an expected call of DeleteReleaseAsset.
func (mr *MockRepositoriesMockRecorder) DeleteReleaseAsset(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReleaseAsset", reflect.TypeOf((*MockRepositories)(nil).DeleteReleaseAsset), arg0, arg1, arg2, arg3)
}

// DisableAutomatedSecurityFixes mocks base method.
func (m *MockRepositories) DisableAutomatedSecurityFixes(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableAutomatedSecurityFixes", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableAutomatedSecurityFixes indicates an expected call of DisableAutomatedSecurityFixes.
func (mr *MockRepositoriesMockRecorder) DisableAutomatedSecurityFixes(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAutomatedSecurityFixes", reflect.TypeOf((*MockRepositories)(nil).DisableAutomatedSecurityFixes), arg0, arg1, arg2)
}

// DisableDismissalRestrictions mocks base method.
func (m *MockRepositories) DisableDismissalRestrictions(arg0 context.Context, arg1, arg2, arg3 string) (*github.PullRequestReviewsEnforcement, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableDismissalRestrictions", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.PullRequestReviewsEnforcement)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DisableDismissalRestrictions indicates an expected call of DisableDismissalRestrictions.
func (mr *MockRepositoriesMockRecorder) DisableDismissalRestrictions(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableDismissalRestrictions", reflect.TypeOf((*MockRepositories)(nil).DisableDismissalRestrictions), arg0, arg1, arg2, arg3)
}

// DisablePages mocks base method.
func (m *MockRepositories) DisablePages(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisablePages", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisablePages indicates an expected call of DisablePages.
func (mr *MockRepositoriesMockRecorder) DisablePages(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisablePages", reflect.TypeOf((*MockRepositories)(nil).DisablePages), arg0, arg1, arg2)
}

// DisableVulnerabilityAlerts mocks base method.
func (m *MockRepositories) DisableVulnerabilityAlerts(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableVulnerabilityAlerts", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableVulnerabilityAlerts indicates an expected call of DisableVulnerabilityAlerts.
func (mr *MockRepositoriesMockRecorder) DisableVulnerabilityAlerts(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVulnerabilityAlerts", reflect.TypeOf((*MockRepositories)(nil).DisableVulnerabilityAlerts), arg0, arg1, arg2)
}

// Dispatch mocks base method.
func (m *MockRepositories) Dispatch(arg0 context.Context, arg1, arg2 string, arg3 github.DispatchRequestOptions) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Dispatch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Dispatch indicates an expected call of Dispatch.
func (mr *MockRepositoriesMockRecorder) Dispatch(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dispatch", reflect.TypeOf((*MockRepositories)(nil).Dispatch), arg0, arg1, arg2, arg3)
}

// DownloadContents mocks base method.
func (m *MockRepositories) DownloadContents(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentGetOptions) (io.ReadCloser, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadContents", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DownloadContents indicates an expected call of DownloadContents.
func (mr *MockRepositoriesMockRecorder) DownloadContents(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadContents", reflect.TypeOf((*MockRepositories)(nil).DownloadContents), arg0, arg1, arg2, arg3, arg4)
}

// DownloadContentsWithMeta mocks base method.
func (m *MockRepositories) DownloadContentsWithMeta(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentGetOptions) (io.ReadCloser, *github.RepositoryContent, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadContentsWithMeta", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(*github.RepositoryContent)
	ret2, _ := ret[2].(*github.Response)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// DownloadContentsWithMeta indicates an expected call of DownloadContentsWithMeta.
func (mr *MockRepositoriesMockRecorder) DownloadContentsWithMeta(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadContentsWithMeta", reflect.TypeOf((*MockRepositories)(nil).DownloadContentsWithMeta), arg0, arg1, arg2, arg3, arg4)
}

// DownloadReleaseAsset mocks base method.
func (m *MockRepositories) DownloadReleaseAsset(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *http.Client) (io.ReadCloser, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DownloadReleaseAsset", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DownloadReleaseAsset indicates an expected call of DownloadReleaseAsset.
func (mr *MockRepositoriesMockRecorder) DownloadReleaseAsset(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadReleaseAsset", reflect.TypeOf((*MockRepositories)(nil).DownloadReleaseAsset), arg0, arg1, arg2, arg3, arg4)
}

// Edit mocks base method.
func (m *MockRepositories) Edit(arg0 context.Context, arg1, arg2 string, arg3 *github.Repository) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Edit", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Edit indicates an expected call of Edit.
func (mr *MockRepositoriesMockRecorder) Edit(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Edit", reflect.TypeOf((*MockRepositories)(nil).Edit), arg0, arg1, arg2, arg3)
}

// EditHook mocks base method.
func (m *MockRepositories) EditHook(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.Hook) (*github.Hook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EditHook", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.Hook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EditHook indicates an expected call of EditHook.
func (mr *MockRepositoriesMockRecorder) EditHook(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditHook", reflect.TypeOf((*MockRepositories)(nil).EditHook), arg0, arg1, arg2, arg3, arg4)
}

// EditRelease mocks base method.
func (m *MockRepositories) EditRelease(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.RepositoryRelease) (*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EditRelease", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EditRelease indicates an expected call of EditRelease.
func (mr *MockRepositoriesMockRecorder) EditRelease(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditRelease", reflect.TypeOf((*MockRepositories)(nil).EditRelease), arg0, arg1, arg2, arg3, arg4)
}

// EditReleaseAsset mocks base method.
func (m *MockRepositories) EditReleaseAsset(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.ReleaseAsset) (*github.ReleaseAsset, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EditReleaseAsset", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.ReleaseAsset)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EditReleaseAsset indicates an expected call of EditReleaseAsset.
func (mr *MockRepositoriesMockRecorder) EditReleaseAsset(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditReleaseAsset", reflect.TypeOf((*MockRepositories)(nil).EditReleaseAsset), arg0, arg1, arg2, arg3, arg4)
}

// EnableAutomatedSecurityFixes mocks base method.
func (m *MockRepositories) EnableAutomatedSecurityFixes(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableAutomatedSecurityFixes", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableAutomatedSecurityFixes indicates an expected call of EnableAutomatedSecurityFixes.
func (mr *MockRepositoriesMockRecorder) EnableAutomatedSecurityFixes(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAutomatedSecurityFixes", reflect.TypeOf((*MockRepositories)(nil).EnableAutomatedSecurityFixes), arg0, arg1, arg2)
}

// EnablePages mocks base method.
func (m *MockRepositories) EnablePages(arg0 context.Context, arg1, arg2 string, arg3 *github.Pages) (*github.Pages, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnablePages", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Pages)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EnablePages indicates an expected call of EnablePages.
func (mr *MockRepositoriesMockRecorder) EnablePages(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnablePages", reflect.TypeOf((*MockRepositories)(nil).EnablePages), arg0, arg1, arg2, arg3)
}

// EnableVulnerabilityAlerts mocks base method.
func (m *MockRepositories) EnableVulnerabilityAlerts(arg0 context.Context, arg1, arg2 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableVulnerabilityAlerts", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableVulnerabilityAlerts indicates an expected call of EnableVulnerabilityAlerts.
func (mr *MockRepositoriesMockRecorder) EnableVulnerabilityAlerts(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVulnerabilityAlerts", reflect.TypeOf((*MockRepositories)(nil).EnableVulnerabilityAlerts), arg0, arg1, arg2)
}

// Get mocks base method.
func (m *MockRepositories) Get(arg0 context.Context, arg1, arg2 string) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockRepositoriesMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRepositories)(nil).Get), arg0, arg1, arg2)
}

// GetAdminEnforcement mocks base method.
func (m *MockRepositories) GetAdminEnforcement(arg0 context.Context, arg1, arg2, arg3 string) (*github.AdminEnforcement, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAdminEnforcement", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.AdminEnforcement)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetAdminEnforcement indicates an expected call of GetAdminEnforcement.
func (mr *MockRepositoriesMockRecorder) GetAdminEnforcement(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAdminEnforcement", reflect.TypeOf((*MockRepositories)(nil).GetAdminEnforcement), arg0, arg1, arg2, arg3)
}

// GetArchiveLink mocks base method.
func (m *MockRepositories) GetArchiveLink(arg0 context.Context, arg1, arg2 string, arg3 github.ArchiveFormat, arg4 *github.RepositoryContentGetOptions, arg5 bool) (*url.URL, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArchiveLink", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*url.URL)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetArchiveLink indicates an expected call of GetArchiveLink.
func (mr *MockRepositoriesMockRecorder) GetArchiveLink(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArchiveLink", reflect.TypeOf((*MockRepositories)(nil).GetArchiveLink), arg0, arg1, arg2, arg3, arg4, arg5)
}

// GetBranch mocks base method.
func (m *MockRepositories) GetBranch(arg0 context.Context, arg1, arg2, arg3 string, arg4 bool) (*github.Branch, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranch", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.Branch)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetBranch indicates an expected call of GetBranch.
func (mr *MockRepositoriesMockRecorder) GetBranch(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranch", reflect.TypeOf((*MockRepositories)(nil).GetBranch), arg0, arg1, arg2, arg3, arg4)
}

// GetBranchProtection mocks base method.
func (m *MockRepositories) GetBranchProtection(arg0 context.Context, arg1, arg2, arg3 string) (*github.Protection, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBranchProtection", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Protection)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetBranchProtection indicates an expected call of GetBranchProtection.
func (mr *MockRepositoriesMockRecorder) GetBranchProtection(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBranchProtection", reflect.TypeOf((*MockRepositories)(nil).GetBranchProtection), arg0, arg1, arg2, arg3)
}

// GetByID mocks base method.
func (m *MockRepositories) GetByID(arg0 context.Context, arg1 int64) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", arg0, arg1)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockRepositoriesMockRecorder) GetByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockRepositories)(nil).GetByID), arg0, arg1)
}

// GetCodeOfConduct mocks base method.
func (m *MockRepositories) GetCodeOfConduct(arg0 context.Context, arg1, arg2 string) (*github.CodeOfConduct, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCodeOfConduct", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.CodeOfConduct)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCodeOfConduct indicates an expected call of GetCodeOfConduct.
func (mr *MockRepositoriesMockRecorder) GetCodeOfConduct(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCodeOfConduct", reflect.TypeOf((*MockRepositories)(nil).GetCodeOfConduct), arg0, arg1, arg2)
}

// GetCombinedStatus mocks base method.
func (m *MockRepositories) GetCombinedStatus(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.ListOptions) (*github.CombinedStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCombinedStatus", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.CombinedStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCombinedStatus indicates an expected call of GetCombinedStatus.
func (mr *MockRepositoriesMockRecorder) GetCombinedStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCombinedStatus", reflect.TypeOf((*MockRepositories)(nil).GetCombinedStatus), arg0, arg1, arg2, arg3, arg4)
}

// GetComment mocks base method.
func (m *MockRepositories) GetComment(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.RepositoryComment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetComment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryComment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetComment indicates an expected call of GetComment.
func (mr *MockRepositoriesMockRecorder) GetComment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComment", reflect.TypeOf((*MockRepositories)(nil).GetComment), arg0, arg1, arg2, arg3)
}

// GetCommit mocks base method.
func (m *MockRepositories) GetCommit(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.ListOptions) (*github.RepositoryCommit, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommit", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryCommit)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockRepositoriesMockRecorder) GetCommit(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockRepositories)(nil).GetCommit), arg0, arg1, arg2, arg3, arg4)
}

// GetCommitRaw mocks base method.
func (m *MockRepositories) GetCommitRaw(arg0 context.Context, arg1, arg2, arg3 string, arg4 github.RawOptions) (string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitRaw", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitRaw indicates an expected call of GetCommitRaw.
func (mr *MockRepositoriesMockRecorder) GetCommitRaw(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitRaw", reflect.TypeOf((*MockRepositories)(nil).GetCommitRaw), arg0, arg1, arg2, arg3, arg4)
}

// GetCommitSHA1 mocks base method.
func (m *MockRepositories) GetCommitSHA1(arg0 context.Context, arg1, arg2, arg3, arg4 string) (string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitSHA1", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitSHA1 indicates an expected call of GetCommitSHA1.
func (mr *MockRepositoriesMockRecorder) GetCommitSHA1(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitSHA1", reflect.TypeOf((*MockRepositories)(nil).GetCommitSHA1), arg0, arg1, arg2, arg3, arg4)
}

// GetCommunityHealthMetrics mocks base method.
func (m *MockRepositories) GetCommunityHealthMetrics(arg0 context.Context, arg1, arg2 string) (*github.CommunityHealthMetrics, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommunityHealthMetrics", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.CommunityHealthMetrics)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommunityHealthMetrics indicates an expected call of GetCommunityHealthMetrics.
func (mr *MockRepositoriesMockRecorder) GetCommunityHealthMetrics(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommunityHealthMetrics", reflect.TypeOf((*MockRepositories)(nil).GetCommunityHealthMetrics), arg0, arg1, arg2)
}

// GetContents mocks base method.
func (m *MockRepositories) GetContents(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentGetOptions) (*github.RepositoryContent, []*github.RepositoryContent, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContents", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryContent)
	ret1, _ := ret[1].([]*github.RepositoryContent)
	ret2, _ := ret[2].(*github.Response)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// GetContents indicates an expected call of GetContents.
func (mr *MockRepositoriesMockRecorder) GetContents(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContents", reflect.TypeOf((*MockRepositories)(nil).GetContents), arg0, arg1, arg2, arg3, arg4)
}

// GetDeployment mocks base method.
func (m *MockRepositories) GetDeployment(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Deployment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeployment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Deployment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetDeployment indicates an expected call of GetDeployment.
func (mr *MockRepositoriesMockRecorder) GetDeployment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployment", reflect.TypeOf((*MockRepositories)(nil).GetDeployment), arg0, arg1, arg2, arg3)
}

// GetDeploymentStatus mocks base method.
func (m *MockRepositories) GetDeploymentStatus(arg0 context.Context, arg1, arg2 string, arg3, arg4 int64) (*github.DeploymentStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentStatus", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.DeploymentStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetDeploymentStatus indicates an expected call of GetDeploymentStatus.
func (mr *MockRepositoriesMockRecorder) GetDeploymentStatus(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentStatus", reflect.TypeOf((*MockRepositories)(nil).GetDeploymentStatus), arg0, arg1, arg2, arg3, arg4)
}

// GetEnvironment mocks base method.
func (m *MockRepositories) GetEnvironment(arg0 context.Context, arg1, arg2, arg3 string) (*github.Environment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnvironment", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Environment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetEnvironment indicates an expected call of GetEnvironment.
func (mr *MockRepositoriesMockRecorder) GetEnvironment(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnvironment", reflect.TypeOf((*MockRepositories)(nil).GetEnvironment), arg0, arg1, arg2, arg3)
}

// GetHook mocks base method.
func (m *MockRepositories) GetHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Hook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Hook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetHook indicates an expected call of GetHook.
func (mr *MockRepositoriesMockRecorder) GetHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHook", reflect.TypeOf((*MockRepositories)(nil).GetHook), arg0, arg1, arg2, arg3)
}

// GetKey mocks base method.
func (m *MockRepositories) GetKey(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Key, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKey", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Key)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetKey indicates an expected call of GetKey.
func (mr *MockRepositoriesMockRecorder) GetKey(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKey", reflect.TypeOf((*MockRepositories)(nil).GetKey), arg0, arg1, arg2, arg3)
}

// GetLatestPagesBuild mocks base method.
func (m *MockRepositories) GetLatestPagesBuild(arg0 context.Context, arg1, arg2 string) (*github.PagesBuild, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestPagesBuild", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.PagesBuild)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLatestPagesBuild indicates an expected call of GetLatestPagesBuild.
func (mr *MockRepositoriesMockRecorder) GetLatestPagesBuild(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestPagesBuild", reflect.TypeOf((*MockRepositories)(nil).GetLatestPagesBuild), arg0, arg1, arg2)
}

// GetLatestRelease mocks base method.
func (m *MockRepositories) GetLatestRelease(arg0 context.Context, arg1, arg2 string) (*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestRelease", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLatestRelease indicates an expected call of GetLatestRelease.
func (mr *MockRepositoriesMockRecorder) GetLatestRelease(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestRelease", reflect.TypeOf((*MockRepositories)(nil).GetLatestRelease), arg0, arg1, arg2)
}

// GetPageBuild mocks base method.
func (m *MockRepositories) GetPageBuild(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.PagesBuild, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPageBuild", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.PagesBuild)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPageBuild indicates an expected call of GetPageBuild.
func (mr *MockRepositoriesMockRecorder) GetPageBuild(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPageBuild", reflect.TypeOf((*MockRepositories)(nil).GetPageBuild), arg0, arg1, arg2, arg3)
}

// GetPagesInfo mocks base method.
func (m *MockRepositories) GetPagesInfo(arg0 context.Context, arg1, arg2 string) (*github.Pages, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPagesInfo", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.Pages)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPagesInfo indicates an expected call of GetPagesInfo.
func (mr *MockRepositoriesMockRecorder) GetPagesInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPagesInfo", reflect.TypeOf((*MockRepositories)(nil).GetPagesInfo), arg0, arg1, arg2)
}

// GetPermissionLevel mocks base method.
func (m *MockRepositories) GetPermissionLevel(arg0 context.Context, arg1, arg2, arg3 string) (*github.RepositoryPermissionLevel, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPermissionLevel", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryPermissionLevel)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPermissionLevel indicates an expected call of GetPermissionLevel.
func (mr *MockRepositoriesMockRecorder) GetPermissionLevel(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPermissionLevel", reflect.TypeOf((*MockRepositories)(nil).GetPermissionLevel), arg0, arg1, arg2, arg3)
}

// GetPreReceiveHook mocks base method.
func (m *MockRepositories) GetPreReceiveHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.PreReceiveHook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPreReceiveHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.PreReceiveHook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPreReceiveHook indicates an expected call of GetPreReceiveHook.
func (mr *MockRepositoriesMockRecorder) GetPreReceiveHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPreReceiveHook", reflect.TypeOf((*MockRepositories)(nil).GetPreReceiveHook), arg0, arg1, arg2, arg3)
}

// GetPullRequestReviewEnforcement mocks base method.
func (m *MockRepositories) GetPullRequestReviewEnforcement(arg0 context.Context, arg1, arg2, arg3 string) (*github.PullRequestReviewsEnforcement, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPullRequestReviewEnforcement", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.PullRequestReviewsEnforcement)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPullRequestReviewEnforcement indicates an expected call of GetPullRequestReviewEnforcement.
func (mr *MockRepositoriesMockRecorder) GetPullRequestReviewEnforcement(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviewEnforcement", reflect.TypeOf((*MockRepositories)(nil).GetPullRequestReviewEnforcement), arg0, arg1, arg2, arg3)
}

// GetReadme mocks base method.
func (m *MockRepositories) GetReadme(arg0 context.Context, arg1, arg2 string, arg3 *github.RepositoryContentGetOptions) (*github.RepositoryContent, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReadme", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryContent)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetReadme indicates an expected call of GetReadme.
func (mr *MockRepositoriesMockRecorder) GetReadme(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReadme", reflect.TypeOf((*MockRepositories)(nil).GetReadme), arg0, arg1, arg2, arg3)
}

// GetRelease mocks base method.
func (m *MockRepositories) GetRelease(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRelease", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRelease indicates an expected call of GetRelease.
func (mr *MockRepositoriesMockRecorder) GetRelease(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRelease", reflect.TypeOf((*MockRepositories)(nil).GetRelease), arg0, arg1, arg2, arg3)
}

// GetReleaseAsset mocks base method.
func (m *MockRepositories) GetReleaseAsset(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.ReleaseAsset, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReleaseAsset", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.ReleaseAsset)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetReleaseAsset indicates an expected call of GetReleaseAsset.
func (mr *MockRepositoriesMockRecorder) GetReleaseAsset(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReleaseAsset", reflect.TypeOf((*MockRepositories)(nil).GetReleaseAsset), arg0, arg1, arg2, arg3)
}

// GetReleaseByTag mocks base method.
func (m *MockRepositories) GetReleaseByTag(arg0 context.Context, arg1, arg2, arg3 string) (*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReleaseByTag", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetReleaseByTag indicates an expected call of GetReleaseByTag.
func (mr *MockRepositoriesMockRecorder) GetReleaseByTag(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReleaseByTag", reflect.TypeOf((*MockRepositories)(nil).GetReleaseByTag), arg0, arg1, arg2, arg3)
}

// GetRequiredStatusChecks mocks base method.
func (m *MockRepositories) GetRequiredStatusChecks(arg0 context.Context, arg1, arg2, arg3 string) (*github.RequiredStatusChecks, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRequiredStatusChecks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RequiredStatusChecks)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRequiredStatusChecks indicates an expected call of GetRequiredStatusChecks.
func (mr *MockRepositoriesMockRecorder) GetRequiredStatusChecks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRequiredStatusChecks", reflect.TypeOf((*MockRepositories)(nil).GetRequiredStatusChecks), arg0, arg1, arg2, arg3)
}

// GetSignaturesProtectedBranch mocks base method.
func (m *MockRepositories) GetSignaturesProtectedBranch(arg0 context.Context, arg1, arg2, arg3 string) (*github.SignaturesProtectedBranch, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignaturesProtectedBranch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.SignaturesProtectedBranch)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSignaturesProtectedBranch indicates an expected call of GetSignaturesProtectedBranch.
func (mr *MockRepositoriesMockRecorder) GetSignaturesProtectedBranch(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignaturesProtectedBranch", reflect.TypeOf((*MockRepositories)(nil).GetSignaturesProtectedBranch), arg0, arg1, arg2, arg3)
}

// GetVulnerabilityAlerts mocks base method.
func (m *MockRepositories) GetVulnerabilityAlerts(arg0 context.Context, arg1, arg2 string) (bool, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVulnerabilityAlerts", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetVulnerabilityAlerts indicates an expected call of GetVulnerabilityAlerts.
func (mr *MockRepositoriesMockRecorder) GetVulnerabilityAlerts(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVulnerabilityAlerts", reflect.TypeOf((*MockRepositories)(nil).GetVulnerabilityAlerts), arg0, arg1, arg2)
}

// IsCollaborator mocks base method.
func (m *MockRepositories) IsCollaborator(arg0 context.Context, arg1, arg2, arg3 string) (bool, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsCollaborator", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// IsCollaborator indicates an expected call of IsCollaborator.
func (mr *MockRepositoriesMockRecorder) IsCollaborator(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCollaborator", reflect.TypeOf((*MockRepositories)(nil).IsCollaborator), arg0, arg1, arg2, arg3)
}

// License mocks base method.
func (m *MockRepositories) License(arg0 context.Context, arg1, arg2 string) (*github.RepositoryLicense, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "License", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.RepositoryLicense)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// License indicates an expected call of License.
func (mr *MockRepositoriesMockRecorder) License(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "License", reflect.TypeOf((*MockRepositories)(nil).License), arg0, arg1, arg2)
}

// List mocks base method.
func (m *MockRepositories) List(arg0 context.Context, arg1 string, arg2 *github.RepositoryListOptions) ([]*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockRepositoriesMockRecorder) List(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRepositories)(nil).List), arg0, arg1, arg2)
}

// ListAll mocks base method.
func (m *MockRepositories) ListAll(arg0 context.Context, arg1 *github.RepositoryListAllOptions) ([]*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAll", arg0, arg1)
	ret0, _ := ret[0].([]*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListAll indicates an expected call of ListAll.
func (mr *MockRepositoriesMockRecorder) ListAll(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAll", reflect.TypeOf((*MockRepositories)(nil).ListAll), arg0, arg1)
}

// ListAllTopics mocks base method.
func (m *MockRepositories) ListAllTopics(arg0 context.Context, arg1, arg2 string) ([]string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllTopics", arg0, arg1, arg2)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListAllTopics indicates an expected call of ListAllTopics.
func (mr *MockRepositoriesMockRecorder) ListAllTopics(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllTopics", reflect.TypeOf((*MockRepositories)(nil).ListAllTopics), arg0, arg1, arg2)
}

// ListApps mocks base method.
func (m *MockRepositories) ListApps(arg0 context.Context, arg1, arg2, arg3 string) ([]*github.App, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApps", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.App)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListApps indicates an expected call of ListApps.
func (mr *MockRepositoriesMockRecorder) ListApps(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApps", reflect.TypeOf((*MockRepositories)(nil).ListApps), arg0, arg1, arg2, arg3)
}

// ListBranches mocks base method.
func (m *MockRepositories) ListBranches(arg0 context.Context, arg1, arg2 string, arg3 *github.BranchListOptions) ([]*github.Branch, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranches", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Branch)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListBranches indicates an expected call of ListBranches.
func (mr *MockRepositoriesMockRecorder) ListBranches(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranches", reflect.TypeOf((*MockRepositories)(nil).ListBranches), arg0, arg1, arg2, arg3)
}

// ListBranchesHeadCommit mocks base method.
func (m *MockRepositories) ListBranchesHeadCommit(arg0 context.Context, arg1, arg2, arg3 string) ([]*github.BranchCommit, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBranchesHeadCommit", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.BranchCommit)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListBranchesHeadCommit indicates an expected call of ListBranchesHeadCommit.
func (mr *MockRepositoriesMockRecorder) ListBranchesHeadCommit(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBranchesHeadCommit", reflect.TypeOf((*MockRepositories)(nil).ListBranchesHeadCommit), arg0, arg1, arg2, arg3)
}

// ListByOrg mocks base method.
func (m *MockRepositories) ListByOrg(arg0 context.Context, arg1 string, arg2 *github.RepositoryListByOrgOptions) ([]*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByOrg", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListByOrg indicates an expected call of ListByOrg.
func (mr *MockRepositoriesMockRecorder) ListByOrg(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByOrg", reflect.TypeOf((*MockRepositories)(nil).ListByOrg), arg0, arg1, arg2)
}

// ListCodeFrequency mocks base method.
func (m *MockRepositories) ListCodeFrequency(arg0 context.Context, arg1, arg2 string) ([]*github.WeeklyStats, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCodeFrequency", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.WeeklyStats)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCodeFrequency indicates an expected call of ListCodeFrequency.
func (mr *MockRepositoriesMockRecorder) ListCodeFrequency(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCodeFrequency", reflect.TypeOf((*MockRepositories)(nil).ListCodeFrequency), arg0, arg1, arg2)
}

// ListCollaborators mocks base method.
func (m *MockRepositories) ListCollaborators(arg0 context.Context, arg1, arg2 string, arg3 *github.ListCollaboratorsOptions) ([]*github.User, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCollaborators", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.User)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCollaborators indicates an expected call of ListCollaborators.
func (mr *MockRepositoriesMockRecorder) ListCollaborators(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCollaborators", reflect.TypeOf((*MockRepositories)(nil).ListCollaborators), arg0, arg1, arg2, arg3)
}

// ListComments mocks base method.
func (m *MockRepositories) ListComments(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.RepositoryComment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListComments", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.RepositoryComment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListComments indicates an expected call of ListComments.
func (mr *MockRepositoriesMockRecorder) ListComments(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListComments", reflect.TypeOf((*MockRepositories)(nil).ListComments), arg0, arg1, arg2, arg3)
}

// ListCommitActivity mocks base method.
func (m *MockRepositories) ListCommitActivity(arg0 context.Context, arg1, arg2 string) ([]*github.WeeklyCommitActivity, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitActivity", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.WeeklyCommitActivity)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCommitActivity indicates an expected call of ListCommitActivity.
func (mr *MockRepositoriesMockRecorder) ListCommitActivity(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitActivity", reflect.TypeOf((*MockRepositories)(nil).ListCommitActivity), arg0, arg1, arg2)
}

// ListCommitComments mocks base method.
func (m *MockRepositories) ListCommitComments(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.ListOptions) ([]*github.RepositoryComment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitComments", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.RepositoryComment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCommitComments indicates an expected call of ListCommitComments.
func (mr *MockRepositoriesMockRecorder) ListCommitComments(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitComments", reflect.TypeOf((*MockRepositories)(nil).ListCommitComments), arg0, arg1, arg2, arg3, arg4)
}

// ListCommits mocks base method.
func (m *MockRepositories) ListCommits(arg0 context.Context, arg1, arg2 string, arg3 *github.CommitsListOptions) ([]*github.RepositoryCommit, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.RepositoryCommit)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockRepositoriesMockRecorder) ListCommits(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockRepositories)(nil).ListCommits), arg0, arg1, arg2, arg3)
}

// ListContributors mocks base method.
func (m *MockRepositories) ListContributors(arg0 context.Context, arg1, arg2 string, arg3 *github.ListContributorsOptions) ([]*github.Contributor, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContributors", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Contributor)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListContributors indicates an expected call of ListContributors.
func (mr *MockRepositoriesMockRecorder) ListContributors(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributors", reflect.TypeOf((*MockRepositories)(nil).ListContributors), arg0, arg1, arg2, arg3)
}

// ListContributorsStats mocks base method.
func (m *MockRepositories) ListContributorsStats(arg0 context.Context, arg1, arg2 string) ([]*github.ContributorStats, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContributorsStats", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.ContributorStats)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListContributorsStats indicates an expected call of ListContributorsStats.
func (mr *MockRepositoriesMockRecorder) ListContributorsStats(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorsStats", reflect.TypeOf((*MockRepositories)(nil).ListContributorsStats), arg0, arg1, arg2)
}

// ListDeploymentStatuses mocks base method.
func (m *MockRepositories) ListDeploymentStatuses(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.ListOptions) ([]*github.DeploymentStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeploymentStatuses", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.DeploymentStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListDeploymentStatuses indicates an expected call of ListDeploymentStatuses.
func (mr *MockRepositoriesMockRecorder) ListDeploymentStatuses(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentStatuses", reflect.TypeOf((*MockRepositories)(nil).ListDeploymentStatuses), arg0, arg1, arg2, arg3, arg4)
}

// ListDeployments mocks base method.
func (m *MockRepositories) ListDeployments(arg0 context.Context, arg1, arg2 string, arg3 *github.DeploymentsListOptions) ([]*github.Deployment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeployments", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Deployment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListDeployments indicates an expected call of ListDeployments.
func (mr *MockRepositoriesMockRecorder) ListDeployments(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeployments", reflect.TypeOf((*MockRepositories)(nil).ListDeployments), arg0, arg1, arg2, arg3)
}

// ListEnvironments mocks base method.
func (m *MockRepositories) ListEnvironments(arg0 context.Context, arg1, arg2 string, arg3 *github.EnvironmentListOptions) (*github.EnvResponse, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEnvironments", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.EnvResponse)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListEnvironments indicates an expected call of ListEnvironments.
func (mr *MockRepositoriesMockRecorder) ListEnvironments(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEnvironments", reflect.TypeOf((*MockRepositories)(nil).ListEnvironments), arg0, arg1, arg2, arg3)
}

// ListForks mocks base method.
func (m *MockRepositories) ListForks(arg0 context.Context, arg1, arg2 string, arg3 *github.RepositoryListForksOptions) ([]*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListForks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListForks indicates an expected call of ListForks.
func (mr *MockRepositoriesMockRecorder) ListForks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListForks", reflect.TypeOf((*MockRepositories)(nil).ListForks), arg0, arg1, arg2, arg3)
}

// ListHooks mocks base method.
func (m *MockRepositories) ListHooks(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.Hook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHooks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Hook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListHooks indicates an expected call of ListHooks.
func (mr *MockRepositoriesMockRecorder) ListHooks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHooks", reflect.TypeOf((*MockRepositories)(nil).ListHooks), arg0, arg1, arg2, arg3)
}

// ListInvitations mocks base method.
func (m *MockRepositories) ListInvitations(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.RepositoryInvitation, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInvitations", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.RepositoryInvitation)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListInvitations indicates an expected call of ListInvitations.
func (mr *MockRepositoriesMockRecorder) ListInvitations(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInvitations", reflect.TypeOf((*MockRepositories)(nil).ListInvitations), arg0, arg1, arg2, arg3)
}

// ListKeys mocks base method.
func (m *MockRepositories) ListKeys(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.Key, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListKeys", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Key)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListKeys indicates an expected call of ListKeys.
func (mr *MockRepositoriesMockRecorder) ListKeys(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockRepositories)(nil).ListKeys), arg0, arg1, arg2, arg3)
}

// ListLanguages mocks base method.
func (m *MockRepositories) ListLanguages(arg0 context.Context, arg1, arg2 string) (map[string]int, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLanguages", arg0, arg1, arg2)
	ret0, _ := ret[0].(map[string]int)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListLanguages indicates an expected call of ListLanguages.
func (mr *MockRepositoriesMockRecorder) ListLanguages(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLanguages", reflect.TypeOf((*MockRepositories)(nil).ListLanguages), arg0, arg1, arg2)
}

// ListPagesBuilds mocks base method.
func (m *MockRepositories) ListPagesBuilds(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.PagesBuild, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPagesBuilds", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.PagesBuild)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPagesBuilds indicates an expected call of ListPagesBuilds.
func (mr *MockRepositoriesMockRecorder) ListPagesBuilds(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPagesBuilds", reflect.TypeOf((*MockRepositories)(nil).ListPagesBuilds), arg0, arg1, arg2, arg3)
}

// ListParticipation mocks base method.
func (m *MockRepositories) ListParticipation(arg0 context.Context, arg1, arg2 string) (*github.RepositoryParticipation, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListParticipation", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.RepositoryParticipation)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListParticipation indicates an expected call of ListParticipation.
func (mr *MockRepositoriesMockRecorder) ListParticipation(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListParticipation", reflect.TypeOf((*MockRepositories)(nil).ListParticipation), arg0, arg1, arg2)
}

// ListPreReceiveHooks mocks base method.
func (m *MockRepositories) ListPreReceiveHooks(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.PreReceiveHook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPreReceiveHooks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.PreReceiveHook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPreReceiveHooks indicates an expected call of ListPreReceiveHooks.
func (mr *MockRepositoriesMockRecorder) ListPreReceiveHooks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPreReceiveHooks", reflect.TypeOf((*MockRepositories)(nil).ListPreReceiveHooks), arg0, arg1, arg2, arg3)
}

// ListProjects mocks base method.
func (m *MockRepositories) ListProjects(arg0 context.Context, arg1, arg2 string, arg3 *github.ProjectListOptions) ([]*github.Project, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjects", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Project)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListProjects indicates an expected call of ListProjects.
func (mr *MockRepositoriesMockRecorder) ListProjects(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjects", reflect.TypeOf((*MockRepositories)(nil).ListProjects), arg0, arg1, arg2, arg3)
}

// ListPunchCard mocks base method.
func (m *MockRepositories) ListPunchCard(arg0 context.Context, arg1, arg2 string) ([]*github.PunchCard, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPunchCard", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.PunchCard)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListPunchCard indicates an expected call of ListPunchCard.
func (mr *MockRepositoriesMockRecorder) ListPunchCard(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPunchCard", reflect.TypeOf((*MockRepositories)(nil).ListPunchCard), arg0, arg1, arg2)
}

// ListReleaseAssets mocks base method.
func (m *MockRepositories) ListReleaseAssets(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.ListOptions) ([]*github.ReleaseAsset, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReleaseAssets", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.ReleaseAsset)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListReleaseAssets indicates an expected call of ListReleaseAssets.
func (mr *MockRepositoriesMockRecorder) ListReleaseAssets(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReleaseAssets", reflect.TypeOf((*MockRepositories)(nil).ListReleaseAssets), arg0, arg1, arg2, arg3, arg4)
}

// ListReleases mocks base method.
func (m *MockRepositories) ListReleases(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.RepositoryRelease, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReleases", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.RepositoryRelease)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListReleases indicates an expected call of ListReleases.
func (mr *MockRepositoriesMockRecorder) ListReleases(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReleases", reflect.TypeOf((*MockRepositories)(nil).ListReleases), arg0, arg1, arg2, arg3)
}

// ListRequiredStatusChecksContexts mocks base method.
func (m *MockRepositories) ListRequiredStatusChecksContexts(arg0 context.Context, arg1, arg2, arg3 string) ([]string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRequiredStatusChecksContexts", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListRequiredStatusChecksContexts indicates an expected call of ListRequiredStatusChecksContexts.
func (mr *MockRepositoriesMockRecorder) ListRequiredStatusChecksContexts(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRequiredStatusChecksContexts", reflect.TypeOf((*MockRepositories)(nil).ListRequiredStatusChecksContexts), arg0, arg1, arg2, arg3)
}

// ListStatuses mocks base method.
func (m *MockRepositories) ListStatuses(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.ListOptions) ([]*github.RepoStatus, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStatuses", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.RepoStatus)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListStatuses indicates an expected call of ListStatuses.
func (mr *MockRepositoriesMockRecorder) ListStatuses(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStatuses", reflect.TypeOf((*MockRepositories)(nil).ListStatuses), arg0, arg1, arg2, arg3, arg4)
}

// ListTags mocks base method.
func (m *MockRepositories) ListTags(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.RepositoryTag, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTags", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.RepositoryTag)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTags indicates an expected call of ListTags.
func (mr *MockRepositoriesMockRecorder) ListTags(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockRepositories)(nil).ListTags), arg0, arg1, arg2, arg3)
}

// ListTeams mocks base method.
func (m *MockRepositories) ListTeams(arg0 context.Context, arg1, arg2 string, arg3 *github.ListOptions) ([]*github.Team, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTeams", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*github.Team)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTeams indicates an expected call of ListTeams.
func (mr *MockRepositoriesMockRecorder) ListTeams(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTeams", reflect.TypeOf((*MockRepositories)(nil).ListTeams), arg0, arg1, arg2, arg3)
}

// ListTrafficClones mocks base method.
func (m *MockRepositories) ListTrafficClones(arg0 context.Context, arg1, arg2 string, arg3 *github.TrafficBreakdownOptions) (*github.TrafficClones, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrafficClones", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.TrafficClones)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTrafficClones indicates an expected call of ListTrafficClones.
func (mr *MockRepositoriesMockRecorder) ListTrafficClones(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficClones", reflect.TypeOf((*MockRepositories)(nil).ListTrafficClones), arg0, arg1, arg2, arg3)
}

// ListTrafficPaths mocks base method.
func (m *MockRepositories) ListTrafficPaths(arg0 context.Context, arg1, arg2 string) ([]*github.TrafficPath, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrafficPaths", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.TrafficPath)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTrafficPaths indicates an expected call of ListTrafficPaths.
func (mr *MockRepositoriesMockRecorder) ListTrafficPaths(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPaths", reflect.TypeOf((*MockRepositories)(nil).ListTrafficPaths), arg0, arg1, arg2)
}

// ListTrafficReferrers mocks base method.
func (m *MockRepositories) ListTrafficReferrers(arg0 context.Context, arg1, arg2 string) ([]*github.TrafficReferrer, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrafficReferrers", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*github.TrafficReferrer)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTrafficReferrers indicates an expected call of ListTrafficReferrers.
func (mr *MockRepositoriesMockRecorder) ListTrafficReferrers(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficReferrers", reflect.TypeOf((*MockRepositories)(nil).ListTrafficReferrers), arg0, arg1, arg2)
}

// ListTrafficViews mocks base method.
func (m *MockRepositories) ListTrafficViews(arg0 context.Context, arg1, arg2 string, arg3 *github.TrafficBreakdownOptions) (*github.TrafficViews, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTrafficViews", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.TrafficViews)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListTrafficViews indicates an expected call of ListTrafficViews.
func (mr *MockRepositoriesMockRecorder) ListTrafficViews(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficViews", reflect.TypeOf((*MockRepositories)(nil).ListTrafficViews), arg0, arg1, arg2, arg3)
}

// Merge mocks base method.
func (m *MockRepositories) Merge(arg0 context.Context, arg1, arg2 string, arg3 *github.RepositoryMergeRequest) (*github.RepositoryCommit, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Merge", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.RepositoryCommit)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Merge indicates an expected call of Merge.
func (mr *MockRepositoriesMockRecorder) Merge(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockRepositories)(nil).Merge), arg0, arg1, arg2, arg3)
}

// OptionalSignaturesOnProtectedBranch mocks base method.
func (m *MockRepositories) OptionalSignaturesOnProtectedBranch(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OptionalSignaturesOnProtectedBranch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OptionalSignaturesOnProtectedBranch indicates an expected call of OptionalSignaturesOnProtectedBranch.
func (mr *MockRepositoriesMockRecorder) OptionalSignaturesOnProtectedBranch(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OptionalSignaturesOnProtectedBranch", reflect.TypeOf((*MockRepositories)(nil).OptionalSignaturesOnProtectedBranch), arg0, arg1, arg2, arg3)
}

// PingHook mocks base method.
func (m *MockRepositories) PingHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PingHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PingHook indicates an expected call of PingHook.
func (mr *MockRepositoriesMockRecorder) PingHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingHook", reflect.TypeOf((*MockRepositories)(nil).PingHook), arg0, arg1, arg2, arg3)
}

// RemoveAdminEnforcement mocks base method.
func (m *MockRepositories) RemoveAdminEnforcement(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAdminEnforcement", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveAdminEnforcement indicates an expected call of RemoveAdminEnforcement.
func (mr *MockRepositoriesMockRecorder) RemoveAdminEnforcement(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAdminEnforcement", reflect.TypeOf((*MockRepositories)(nil).RemoveAdminEnforcement), arg0, arg1, arg2, arg3)
}

// RemoveAppRestrictions mocks base method.
func (m *MockRepositories) RemoveAppRestrictions(arg0 context.Context, arg1, arg2, arg3 string, arg4 []string) ([]*github.App, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAppRestrictions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.App)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveAppRestrictions indicates an expected call of RemoveAppRestrictions.
func (mr *MockRepositoriesMockRecorder) RemoveAppRestrictions(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAppRestrictions", reflect.TypeOf((*MockRepositories)(nil).RemoveAppRestrictions), arg0, arg1, arg2, arg3, arg4)
}

// RemoveBranchProtection mocks base method.
func (m *MockRepositories) RemoveBranchProtection(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveBranchProtection", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveBranchProtection indicates an expected call of RemoveBranchProtection.
func (mr *MockRepositoriesMockRecorder) RemoveBranchProtection(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBranchProtection", reflect.TypeOf((*MockRepositories)(nil).RemoveBranchProtection), arg0, arg1, arg2, arg3)
}

// RemoveCollaborator mocks base method.
func (m *MockRepositories) RemoveCollaborator(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveCollaborator", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveCollaborator indicates an expected call of RemoveCollaborator.
func (mr *MockRepositoriesMockRecorder) RemoveCollaborator(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCollaborator", reflect.TypeOf((*MockRepositories)(nil).RemoveCollaborator), arg0, arg1, arg2, arg3)
}

// RemovePullRequestReviewEnforcement mocks base method.
func (m *MockRepositories) RemovePullRequestReviewEnforcement(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePullRequestReviewEnforcement", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemovePullRequestReviewEnforcement indicates an expected call of RemovePullRequestReviewEnforcement.
func (mr *MockRepositoriesMockRecorder) RemovePullRequestReviewEnforcement(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePullRequestReviewEnforcement", reflect.TypeOf((*MockRepositories)(nil).RemovePullRequestReviewEnforcement), arg0, arg1, arg2, arg3)
}

// RemoveRequiredStatusChecks mocks base method.
func (m *MockRepositories) RemoveRequiredStatusChecks(arg0 context.Context, arg1, arg2, arg3 string) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveRequiredStatusChecks", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveRequiredStatusChecks indicates an expected call of RemoveRequiredStatusChecks.
func (mr *MockRepositoriesMockRecorder) RemoveRequiredStatusChecks(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRequiredStatusChecks", reflect.TypeOf((*MockRepositories)(nil).RemoveRequiredStatusChecks), arg0, arg1, arg2, arg3)
}

// ReplaceAllTopics mocks base method.
func (m *MockRepositories) ReplaceAllTopics(arg0 context.Context, arg1, arg2 string, arg3 []string) ([]string, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceAllTopics", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReplaceAllTopics indicates an expected call of ReplaceAllTopics.
func (mr *MockRepositoriesMockRecorder) ReplaceAllTopics(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceAllTopics", reflect.TypeOf((*MockRepositories)(nil).ReplaceAllTopics), arg0, arg1, arg2, arg3)
}

// ReplaceAppRestrictions mocks base method.
func (m *MockRepositories) ReplaceAppRestrictions(arg0 context.Context, arg1, arg2, arg3 string, arg4 []string) ([]*github.App, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceAppRestrictions", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*github.App)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReplaceAppRestrictions indicates an expected call of ReplaceAppRestrictions.
func (mr *MockRepositoriesMockRecorder) ReplaceAppRestrictions(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceAppRestrictions", reflect.TypeOf((*MockRepositories)(nil).ReplaceAppRestrictions), arg0, arg1, arg2, arg3, arg4)
}

// RequestPageBuild mocks base method.
func (m *MockRepositories) RequestPageBuild(arg0 context.Context, arg1, arg2 string) (*github.PagesBuild, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestPageBuild", arg0, arg1, arg2)
	ret0, _ := ret[0].(*github.PagesBuild)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RequestPageBuild indicates an expected call of RequestPageBuild.
func (mr *MockRepositoriesMockRecorder) RequestPageBuild(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestPageBuild", reflect.TypeOf((*MockRepositories)(nil).RequestPageBuild), arg0, arg1, arg2)
}

// RequireSignaturesOnProtectedBranch mocks base method.
func (m *MockRepositories) RequireSignaturesOnProtectedBranch(arg0 context.Context, arg1, arg2, arg3 string) (*github.SignaturesProtectedBranch, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequireSignaturesOnProtectedBranch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.SignaturesProtectedBranch)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RequireSignaturesOnProtectedBranch indicates an expected call of RequireSignaturesOnProtectedBranch.
func (mr *MockRepositoriesMockRecorder) RequireSignaturesOnProtectedBranch(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequireSignaturesOnProtectedBranch", reflect.TypeOf((*MockRepositories)(nil).RequireSignaturesOnProtectedBranch), arg0, arg1, arg2, arg3)
}

// TestHook mocks base method.
func (m *MockRepositories) TestHook(arg0 context.Context, arg1, arg2 string, arg3 int64) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TestHook", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestHook indicates an expected call of TestHook.
func (mr *MockRepositoriesMockRecorder) TestHook(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestHook", reflect.TypeOf((*MockRepositories)(nil).TestHook), arg0, arg1, arg2, arg3)
}

// Transfer mocks base method.
func (m *MockRepositories) Transfer(arg0 context.Context, arg1, arg2 string, arg3 github.TransferRequest) (*github.Repository, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Transfer", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Repository)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Transfer indicates an expected call of Transfer.
func (mr *MockRepositoriesMockRecorder) Transfer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transfer", reflect.TypeOf((*MockRepositories)(nil).Transfer), arg0, arg1, arg2, arg3)
}

// UpdateBranchProtection mocks base method.
func (m *MockRepositories) UpdateBranchProtection(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.ProtectionRequest) (*github.Protection, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBranchProtection", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.Protection)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateBranchProtection indicates an expected call of UpdateBranchProtection.
func (mr *MockRepositoriesMockRecorder) UpdateBranchProtection(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBranchProtection", reflect.TypeOf((*MockRepositories)(nil).UpdateBranchProtection), arg0, arg1, arg2, arg3, arg4)
}

// UpdateComment mocks base method.
func (m *MockRepositories) UpdateComment(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.RepositoryComment) (*github.RepositoryComment, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateComment", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryComment)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateComment indicates an expected call of UpdateComment.
func (mr *MockRepositoriesMockRecorder) UpdateComment(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateComment", reflect.TypeOf((*MockRepositories)(nil).UpdateComment), arg0, arg1, arg2, arg3, arg4)
}

// UpdateFile mocks base method.
func (m *MockRepositories) UpdateFile(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RepositoryContentFileOptions) (*github.RepositoryContentResponse, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFile", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryContentResponse)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateFile indicates an expected call of UpdateFile.
func (mr *MockRepositoriesMockRecorder) UpdateFile(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFile", reflect.TypeOf((*MockRepositories)(nil).UpdateFile), arg0, arg1, arg2, arg3, arg4)
}

// UpdateInvitation mocks base method.
func (m *MockRepositories) UpdateInvitation(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 string) (*github.RepositoryInvitation, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInvitation", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RepositoryInvitation)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateInvitation indicates an expected call of UpdateInvitation.
func (mr *MockRepositoriesMockRecorder) UpdateInvitation(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInvitation", reflect.TypeOf((*MockRepositories)(nil).UpdateInvitation), arg0, arg1, arg2, arg3, arg4)
}

// UpdatePages mocks base method.
func (m *MockRepositories) UpdatePages(arg0 context.Context, arg1, arg2 string, arg3 *github.PagesUpdate) (*github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePages", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*github.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePages indicates an expected call of UpdatePages.
func (mr *MockRepositoriesMockRecorder) UpdatePages(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePages", reflect.TypeOf((*MockRepositories)(nil).UpdatePages), arg0, arg1, arg2, arg3)
}

// UpdatePreReceiveHook mocks base method.
func (m *MockRepositories) UpdatePreReceiveHook(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.PreReceiveHook) (*github.PreReceiveHook, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePreReceiveHook", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.PreReceiveHook)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdatePreReceiveHook indicates an expected call of UpdatePreReceiveHook.
func (mr *MockRepositoriesMockRecorder) UpdatePreReceiveHook(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePreReceiveHook", reflect.TypeOf((*MockRepositories)(nil).UpdatePreReceiveHook), arg0, arg1, arg2, arg3, arg4)
}

// UpdatePullRequestReviewEnforcement mocks base method.
func (m *MockRepositories) UpdatePullRequestReviewEnforcement(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.PullRequestReviewsEnforcementUpdate) (*github.PullRequestReviewsEnforcement, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePullRequestReviewEnforcement", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.PullRequestReviewsEnforcement)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdatePullRequestReviewEnforcement indicates an expected call of UpdatePullRequestReviewEnforcement.
func (mr *MockRepositoriesMockRecorder) UpdatePullRequestReviewEnforcement(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequestReviewEnforcement", reflect.TypeOf((*MockRepositories)(nil).UpdatePullRequestReviewEnforcement), arg0, arg1, arg2, arg3, arg4)
}

// UpdateRequiredStatusChecks mocks base method.
func (m *MockRepositories) UpdateRequiredStatusChecks(arg0 context.Context, arg1, arg2, arg3 string, arg4 *github.RequiredStatusChecksRequest) (*github.RequiredStatusChecks, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRequiredStatusChecks", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*github.RequiredStatusChecks)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateRequiredStatusChecks indicates an expected call of UpdateRequiredStatusChecks.
func (mr *MockRepositoriesMockRecorder) UpdateRequiredStatusChecks(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRequiredStatusChecks", reflect.TypeOf((*MockRepositories)(nil).UpdateRequiredStatusChecks), arg0, arg1, arg2, arg3, arg4)
}

// UploadReleaseAsset mocks base method.
func (m *MockRepositories) UploadReleaseAsset(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 *github.UploadOptions, arg5 *os.File) (*github.ReleaseAsset, *github.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadReleaseAsset", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*github.ReleaseAsset)
	ret1, _ := ret[1].(*github.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UploadReleaseAsset indicates an expected call of UploadReleaseAsset.
func (mr *MockRepositoriesMockRecorder) UploadReleaseAsset(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadReleaseAsset", reflect.TypeOf((*MockRepositories)(nil).UploadReleaseAsset), arg0, arg1, arg2, arg3, arg4, arg5)
}
