// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/tidbcloud/devops/pkg/service/release/repo (interfaces: Repo,TicketDriver,ReleaseDriver)
//
// Generated by this command:
//
//	mockgen -destination repo_mock.go -package=repo github.com/tidbcloud/devops/pkg/service/release/repo Repo,TicketDriver,ReleaseDriver
//

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

import (
	context "context"
	reflect "reflect"

	release "github.com/tidbcloud/devops/entity/release"
	repoopt "github.com/tidbcloud/devops/pkg/infra/utils/repoopt"
	gomock "go.uber.org/mock/gomock"
)

// MockRepo is a mock of Repo interface.
type MockRepo struct {
	ctrl     *gomock.Controller
	recorder *MockRepoMockRecorder
	isgomock struct{}
}

// MockRepoMockRecorder is the mock recorder for MockRepo.
type MockRepoMockRecorder struct {
	mock *MockRepo
}

// NewMockRepo creates a new mock instance.
func NewMockRepo(ctrl *gomock.Controller) *MockRepo {
	mock := &MockRepo{ctrl: ctrl}
	mock.recorder = &MockRepoMockRecorder{mock}
	return mock
}

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

// CountChanges mocks base method.
func (m *MockRepo) CountChanges(ctx context.Context, opts ...repoopt.Option) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountChanges", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountReleases mocks base method.
func (m *MockRepo) CountReleases(ctx context.Context, opts ...repoopt.Option) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountReleases", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountTicket mocks base method.
func (m *MockRepo) CountTicket(ctx context.Context, opts ...repoopt.Option) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountTicket", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateChange mocks base method.
func (m *MockRepo) CreateChange(ctx context.Context, change *release.ChangeInRepo) (*release.ChangeInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChange", ctx, change)
	ret0, _ := ret[0].(*release.ChangeInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateChange indicates an expected call of CreateChange.
func (mr *MockRepoMockRecorder) CreateChange(ctx, change any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChange", reflect.TypeOf((*MockRepo)(nil).CreateChange), ctx, change)
}

// CreateRelease mocks base method.
func (m *MockRepo) CreateRelease(ctx context.Context, arg1 *release.ReleaseInRepo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRelease", ctx, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateRelease indicates an expected call of CreateRelease.
func (mr *MockRepoMockRecorder) CreateRelease(ctx, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRelease", reflect.TypeOf((*MockRepo)(nil).CreateRelease), ctx, arg1)
}

// CreateTicket mocks base method.
func (m *MockRepo) CreateTicket(ctx context.Context, ticket *release.ReleaseTicketInRepo) (*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTicket", ctx, ticket)
	ret0, _ := ret[0].(*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTicket indicates an expected call of CreateTicket.
func (mr *MockRepoMockRecorder) CreateTicket(ctx, ticket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTicket", reflect.TypeOf((*MockRepo)(nil).CreateTicket), ctx, ticket)
}

// GetAndPatchChange mocks base method.
func (m *MockRepo) GetAndPatchChange(ctx context.Context, id uint64, patch ...PatchChange) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, id}
	for _, a := range patch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAndPatchChange", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAndPatchChange indicates an expected call of GetAndPatchChange.
func (mr *MockRepoMockRecorder) GetAndPatchChange(ctx, id any, patch ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, id}, patch...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAndPatchChange", reflect.TypeOf((*MockRepo)(nil).GetAndPatchChange), varargs...)
}

// GetChange mocks base method.
func (m *MockRepo) GetChange(ctx context.Context, id uint64, detail bool) (*release.ChangeInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChange", ctx, id, detail)
	ret0, _ := ret[0].(*release.ChangeInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChange indicates an expected call of GetChange.
func (mr *MockRepoMockRecorder) GetChange(ctx, id, detail any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChange", reflect.TypeOf((*MockRepo)(nil).GetChange), ctx, id, detail)
}

// GetRelease mocks base method.
func (m *MockRepo) GetRelease(ctx context.Context, id uint64) (*release.ReleaseInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRelease", ctx, id)
	ret0, _ := ret[0].(*release.ReleaseInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTicket mocks base method.
func (m *MockRepo) GetTicket(ctx context.Context, name string) (*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTicket", ctx, name)
	ret0, _ := ret[0].(*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTicket indicates an expected call of GetTicket.
func (mr *MockRepoMockRecorder) GetTicket(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTicket", reflect.TypeOf((*MockRepo)(nil).GetTicket), ctx, name)
}

// ListChanges mocks base method.
func (m *MockRepo) ListChanges(ctx context.Context, detail bool, options ...repoopt.Option) ([]*release.ChangeInRepo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, detail}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListChanges", varargs...)
	ret0, _ := ret[0].([]*release.ChangeInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChanges indicates an expected call of ListChanges.
func (mr *MockRepoMockRecorder) ListChanges(ctx, detail any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, detail}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChanges", reflect.TypeOf((*MockRepo)(nil).ListChanges), varargs...)
}

// ListReleases mocks base method.
func (m *MockRepo) ListReleases(ctx context.Context, opts ...repoopt.Option) ([]*release.ReleaseInRepo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListReleases", varargs...)
	ret0, _ := ret[0].([]*release.ReleaseInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTickets mocks base method.
func (m *MockRepo) ListTickets(ctx context.Context, opts ...repoopt.Option) ([]*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTickets", varargs...)
	ret0, _ := ret[0].([]*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PatchChange mocks base method.
func (m *MockRepo) PatchChange(ctx context.Context, current *release.ChangeInRepo, patch ...PatchChange) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, current}
	for _, a := range patch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchChange", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PatchChange indicates an expected call of PatchChange.
func (mr *MockRepoMockRecorder) PatchChange(ctx, current any, patch ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, current}, patch...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchChange", reflect.TypeOf((*MockRepo)(nil).PatchChange), varargs...)
}

// PatchRelease mocks base method.
func (m *MockRepo) PatchRelease(ctx context.Context, id uint64, patch PatchRelease) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PatchRelease", ctx, id, patch)
	ret0, _ := ret[0].(error)
	return ret0
}

// PatchRelease indicates an expected call of PatchRelease.
func (mr *MockRepoMockRecorder) PatchRelease(ctx, id, patch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchRelease", reflect.TypeOf((*MockRepo)(nil).PatchRelease), ctx, id, patch)
}

// PatchTicket mocks base method.
func (m *MockRepo) PatchTicket(ctx context.Context, current *release.ReleaseTicketInRepo, patch ...PatchTicket) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, current}
	for _, a := range patch {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchTicket", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PatchTicket indicates an expected call of PatchTicket.
func (mr *MockRepoMockRecorder) PatchTicket(ctx, current any, patch ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, current}, patch...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTicket", reflect.TypeOf((*MockRepo)(nil).PatchTicket), varargs...)
}

// UpdateRelease mocks base method.
func (m *MockRepo) UpdateRelease(ctx context.Context, arg1 *release.ReleaseInRepo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRelease", ctx, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateRelease indicates an expected call of UpdateRelease.
func (mr *MockRepoMockRecorder) UpdateRelease(ctx, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRelease", reflect.TypeOf((*MockRepo)(nil).UpdateRelease), ctx, arg1)
}

// MockTicketDriver is a mock of TicketDriver interface.
type MockTicketDriver struct {
	ctrl     *gomock.Controller
	recorder *MockTicketDriverMockRecorder
	isgomock struct{}
}

// MockTicketDriverMockRecorder is the mock recorder for MockTicketDriver.
type MockTicketDriverMockRecorder struct {
	mock *MockTicketDriver
}

// NewMockTicketDriver creates a new mock instance.
func NewMockTicketDriver(ctrl *gomock.Controller) *MockTicketDriver {
	mock := &MockTicketDriver{ctrl: ctrl}
	mock.recorder = &MockTicketDriverMockRecorder{mock}
	return mock
}

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

// Count mocks base method.
func (m *MockTicketDriver) Count(ctx context.Context, opts ...repoopt.Option) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Count", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Load mocks base method.
func (m *MockTicketDriver) Load(ctx context.Context, name string) (*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Load", ctx, name)
	ret0, _ := ret[0].(*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Load indicates an expected call of Load.
func (mr *MockTicketDriverMockRecorder) Load(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockTicketDriver)(nil).Load), ctx, name)
}

// Query mocks base method.
func (m *MockTicketDriver) Query(ctx context.Context, opts ...repoopt.Option) ([]*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Query", varargs...)
	ret0, _ := ret[0].([]*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Save mocks base method.
func (m *MockTicketDriver) Save(ctx context.Context, ticket *release.ReleaseTicketInRepo) (*release.ReleaseTicketInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, ticket)
	ret0, _ := ret[0].(*release.ReleaseTicketInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockTicketDriverMockRecorder) Save(ctx, ticket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockTicketDriver)(nil).Save), ctx, ticket)
}

// MockReleaseDriver is a mock of ReleaseDriver interface.
type MockReleaseDriver struct {
	ctrl     *gomock.Controller
	recorder *MockReleaseDriverMockRecorder
	isgomock struct{}
}

// MockReleaseDriverMockRecorder is the mock recorder for MockReleaseDriver.
type MockReleaseDriverMockRecorder struct {
	mock *MockReleaseDriver
}

// NewMockReleaseDriver creates a new mock instance.
func NewMockReleaseDriver(ctrl *gomock.Controller) *MockReleaseDriver {
	mock := &MockReleaseDriver{ctrl: ctrl}
	mock.recorder = &MockReleaseDriverMockRecorder{mock}
	return mock
}

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

// Count mocks base method.
func (m *MockReleaseDriver) Count(ctx context.Context, opts ...repoopt.Option) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Count", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Load mocks base method.
func (m *MockReleaseDriver) Load(ctx context.Context, id uint64) (*release.ReleaseInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Load", ctx, id)
	ret0, _ := ret[0].(*release.ReleaseInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Query mocks base method.
func (m *MockReleaseDriver) Query(ctx context.Context, opts ...repoopt.Option) ([]*release.ReleaseInRepo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Query", varargs...)
	ret0, _ := ret[0].([]*release.ReleaseInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Save mocks base method.
func (m *MockReleaseDriver) Save(ctx context.Context, arg1 *release.ReleaseInRepo) (*release.ReleaseInRepo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, arg1)
	ret0, _ := ret[0].(*release.ReleaseInRepo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockReleaseDriverMockRecorder) Save(ctx, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockReleaseDriver)(nil).Save), ctx, arg1)
}