// Code generated by MockGen. DO NOT EDIT.
// Source: ./modular.go
//
// Generated by this command:
//
//	mockgen -source=./modular.go -destination=./modular_mock.go -package=module
//

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

import (
	context "context"
	io "io"
	reflect "reflect"

	gfspp2p "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspp2p"
	gfspserver "github.com/bnb-chain/greenfield-storage-provider/base/types/gfspserver"
	gfsptask "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask"
	rcmgr "github.com/bnb-chain/greenfield-storage-provider/core/rcmgr"
	spdb "github.com/bnb-chain/greenfield-storage-provider/core/spdb"
	task "github.com/bnb-chain/greenfield-storage-provider/core/task"
	types "github.com/bnb-chain/greenfield/x/sp/types"
	types0 "github.com/bnb-chain/greenfield/x/storage/types"
	types1 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	gomock "go.uber.org/mock/gomock"
)

// MockModular is a mock of Modular interface.
type MockModular struct {
	ctrl     *gomock.Controller
	recorder *MockModularMockRecorder
}

// MockModularMockRecorder is the mock recorder for MockModular.
type MockModularMockRecorder struct {
	mock *MockModular
}

// NewMockModular creates a new mock instance.
func NewMockModular(ctrl *gomock.Controller) *MockModular {
	mock := &MockModular{ctrl: ctrl}
	mock.recorder = &MockModularMockRecorder{mock}
	return mock
}

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

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

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

// ReleaseResource mocks base method.
func (m *MockModular) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockModularMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockModular)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockModular) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockModularMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockModular)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockAuthenticator is a mock of Authenticator interface.
type MockAuthenticator struct {
	ctrl     *gomock.Controller
	recorder *MockAuthenticatorMockRecorder
}

// MockAuthenticatorMockRecorder is the mock recorder for MockAuthenticator.
type MockAuthenticatorMockRecorder struct {
	mock *MockAuthenticator
}

// NewMockAuthenticator creates a new mock instance.
func NewMockAuthenticator(ctrl *gomock.Controller) *MockAuthenticator {
	mock := &MockAuthenticator{ctrl: ctrl}
	mock.recorder = &MockAuthenticatorMockRecorder{mock}
	return mock
}

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

// DeleteAuthKeysV2 mocks base method.
func (m *MockAuthenticator) DeleteAuthKeysV2(ctx context.Context, account, domain string, publicKeys []string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAuthKeysV2", ctx, account, domain, publicKeys)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAuthKeysV2 indicates an expected call of DeleteAuthKeysV2.
func (mr *MockAuthenticatorMockRecorder) DeleteAuthKeysV2(ctx, account, domain, publicKeys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuthKeysV2", reflect.TypeOf((*MockAuthenticator)(nil).DeleteAuthKeysV2), ctx, account, domain, publicKeys)
}

// GetAuthKeyV2 mocks base method.
func (m *MockAuthenticator) GetAuthKeyV2(ctx context.Context, account, domain, publicKey string) (*spdb.OffChainAuthKeyV2, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthKeyV2", ctx, account, domain, publicKey)
	ret0, _ := ret[0].(*spdb.OffChainAuthKeyV2)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthKeyV2 indicates an expected call of GetAuthKeyV2.
func (mr *MockAuthenticatorMockRecorder) GetAuthKeyV2(ctx, account, domain, publicKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthKeyV2", reflect.TypeOf((*MockAuthenticator)(nil).GetAuthKeyV2), ctx, account, domain, publicKey)
}

// GetAuthNonce mocks base method.
func (m *MockAuthenticator) GetAuthNonce(ctx context.Context, account, domain string) (*spdb.OffChainAuthKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthNonce", ctx, account, domain)
	ret0, _ := ret[0].(*spdb.OffChainAuthKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthNonce indicates an expected call of GetAuthNonce.
func (mr *MockAuthenticatorMockRecorder) GetAuthNonce(ctx, account, domain any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthNonce", reflect.TypeOf((*MockAuthenticator)(nil).GetAuthNonce), ctx, account, domain)
}

// ListAuthKeysV2 mocks base method.
func (m *MockAuthenticator) ListAuthKeysV2(ctx context.Context, account, domain string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthKeysV2", ctx, account, domain)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthKeysV2 indicates an expected call of ListAuthKeysV2.
func (mr *MockAuthenticatorMockRecorder) ListAuthKeysV2(ctx, account, domain any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthKeysV2", reflect.TypeOf((*MockAuthenticator)(nil).ListAuthKeysV2), ctx, account, domain)
}

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

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

// ReleaseResource mocks base method.
func (m *MockAuthenticator) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockAuthenticatorMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockAuthenticator)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockAuthenticator) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockAuthenticatorMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockAuthenticator)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// UpdateUserPublicKey mocks base method.
func (m *MockAuthenticator) UpdateUserPublicKey(ctx context.Context, account, domain string, currentNonce, nonce int32, userPublicKey string, expiryDate int64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserPublicKey", ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey.
func (mr *MockAuthenticatorMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockAuthenticator)(nil).UpdateUserPublicKey), ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate)
}

// UpdateUserPublicKeyV2 mocks base method.
func (m *MockAuthenticator) UpdateUserPublicKeyV2(ctx context.Context, account, domain, publicKey string, expiryDate int64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserPublicKeyV2", ctx, account, domain, publicKey, expiryDate)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserPublicKeyV2 indicates an expected call of UpdateUserPublicKeyV2.
func (mr *MockAuthenticatorMockRecorder) UpdateUserPublicKeyV2(ctx, account, domain, publicKey, expiryDate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKeyV2", reflect.TypeOf((*MockAuthenticator)(nil).UpdateUserPublicKeyV2), ctx, account, domain, publicKey, expiryDate)
}

// VerifyAuthentication mocks base method.
func (m *MockAuthenticator) VerifyAuthentication(ctx context.Context, auth AuthOpType, account, bucket, object string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyAuthentication", ctx, auth, account, bucket, object)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyAuthentication indicates an expected call of VerifyAuthentication.
func (mr *MockAuthenticatorMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockAuthenticator)(nil).VerifyAuthentication), ctx, auth, account, bucket, object)
}

// VerifyGNFD1EddsaSignature mocks base method.
func (m *MockAuthenticator) VerifyGNFD1EddsaSignature(ctx context.Context, account, domain, offChainSig string, realMsgToSign []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyGNFD1EddsaSignature", ctx, account, domain, offChainSig, realMsgToSign)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature.
func (mr *MockAuthenticatorMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockAuthenticator)(nil).VerifyGNFD1EddsaSignature), ctx, account, domain, offChainSig, realMsgToSign)
}

// VerifyGNFD2EddsaSignature mocks base method.
func (m *MockAuthenticator) VerifyGNFD2EddsaSignature(ctx context.Context, account, domain, publicKey, offChainSig string, realMsgToSign []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyGNFD2EddsaSignature", ctx, account, domain, publicKey, offChainSig, realMsgToSign)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD2EddsaSignature indicates an expected call of VerifyGNFD2EddsaSignature.
func (mr *MockAuthenticatorMockRecorder) VerifyGNFD2EddsaSignature(ctx, account, domain, publicKey, offChainSig, realMsgToSign any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD2EddsaSignature", reflect.TypeOf((*MockAuthenticator)(nil).VerifyGNFD2EddsaSignature), ctx, account, domain, publicKey, offChainSig, realMsgToSign)
}

// MockApprover is a mock of Approver interface.
type MockApprover struct {
	ctrl     *gomock.Controller
	recorder *MockApproverMockRecorder
}

// MockApproverMockRecorder is the mock recorder for MockApprover.
type MockApproverMockRecorder struct {
	mock *MockApprover
}

// NewMockApprover creates a new mock instance.
func NewMockApprover(ctrl *gomock.Controller) *MockApprover {
	mock := &MockApprover{ctrl: ctrl}
	mock.recorder = &MockApproverMockRecorder{mock}
	return mock
}

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

// HandleCreateBucketApprovalTask mocks base method.
func (m *MockApprover) HandleCreateBucketApprovalTask(ctx context.Context, task task.ApprovalCreateBucketTask) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleCreateBucketApprovalTask", ctx, task)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleCreateBucketApprovalTask indicates an expected call of HandleCreateBucketApprovalTask.
func (mr *MockApproverMockRecorder) HandleCreateBucketApprovalTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateBucketApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleCreateBucketApprovalTask), ctx, task)
}

// HandleCreateObjectApprovalTask mocks base method.
func (m *MockApprover) HandleCreateObjectApprovalTask(ctx context.Context, task task.ApprovalCreateObjectTask) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleCreateObjectApprovalTask", ctx, task)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleCreateObjectApprovalTask indicates an expected call of HandleCreateObjectApprovalTask.
func (mr *MockApproverMockRecorder) HandleCreateObjectApprovalTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateObjectApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleCreateObjectApprovalTask), ctx, task)
}

// HandleDelegateCreateObjectApprovalTask mocks base method.
func (m *MockApprover) HandleDelegateCreateObjectApprovalTask(ctx context.Context, task task.ApprovalDelegateCreateObjectTask) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDelegateCreateObjectApprovalTask", ctx, task)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleDelegateCreateObjectApprovalTask indicates an expected call of HandleDelegateCreateObjectApprovalTask.
func (mr *MockApproverMockRecorder) HandleDelegateCreateObjectApprovalTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDelegateCreateObjectApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleDelegateCreateObjectApprovalTask), ctx, task)
}

// HandleMigrateBucketApprovalTask mocks base method.
func (m *MockApprover) HandleMigrateBucketApprovalTask(ctx context.Context, task task.ApprovalMigrateBucketTask) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleMigrateBucketApprovalTask", ctx, task)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleMigrateBucketApprovalTask indicates an expected call of HandleMigrateBucketApprovalTask.
func (mr *MockApproverMockRecorder) HandleMigrateBucketApprovalTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateBucketApprovalTask", reflect.TypeOf((*MockApprover)(nil).HandleMigrateBucketApprovalTask), ctx, task)
}

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

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

// PostCreateBucketApproval mocks base method.
func (m *MockApprover) PostCreateBucketApproval(ctx context.Context, task task.ApprovalCreateBucketTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostCreateBucketApproval", ctx, task)
}

// PostCreateBucketApproval indicates an expected call of PostCreateBucketApproval.
func (mr *MockApproverMockRecorder) PostCreateBucketApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCreateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PostCreateBucketApproval), ctx, task)
}

// PostCreateObjectApproval mocks base method.
func (m *MockApprover) PostCreateObjectApproval(ctx context.Context, task task.ApprovalCreateObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostCreateObjectApproval", ctx, task)
}

// PostCreateObjectApproval indicates an expected call of PostCreateObjectApproval.
func (mr *MockApproverMockRecorder) PostCreateObjectApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCreateObjectApproval", reflect.TypeOf((*MockApprover)(nil).PostCreateObjectApproval), ctx, task)
}

// PostMigrateBucketApproval mocks base method.
func (m *MockApprover) PostMigrateBucketApproval(ctx context.Context, task task.ApprovalMigrateBucketTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostMigrateBucketApproval", ctx, task)
}

// PostMigrateBucketApproval indicates an expected call of PostMigrateBucketApproval.
func (mr *MockApproverMockRecorder) PostMigrateBucketApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PostMigrateBucketApproval), ctx, task)
}

// PreCreateBucketApproval mocks base method.
func (m *MockApprover) PreCreateBucketApproval(ctx context.Context, task task.ApprovalCreateBucketTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreCreateBucketApproval", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreCreateBucketApproval indicates an expected call of PreCreateBucketApproval.
func (mr *MockApproverMockRecorder) PreCreateBucketApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreCreateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PreCreateBucketApproval), ctx, task)
}

// PreCreateObjectApproval mocks base method.
func (m *MockApprover) PreCreateObjectApproval(ctx context.Context, task task.ApprovalCreateObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreCreateObjectApproval", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreCreateObjectApproval indicates an expected call of PreCreateObjectApproval.
func (mr *MockApproverMockRecorder) PreCreateObjectApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreCreateObjectApproval", reflect.TypeOf((*MockApprover)(nil).PreCreateObjectApproval), ctx, task)
}

// PreMigrateBucketApproval mocks base method.
func (m *MockApprover) PreMigrateBucketApproval(ctx context.Context, task task.ApprovalMigrateBucketTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreMigrateBucketApproval", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreMigrateBucketApproval indicates an expected call of PreMigrateBucketApproval.
func (mr *MockApproverMockRecorder) PreMigrateBucketApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucketApproval", reflect.TypeOf((*MockApprover)(nil).PreMigrateBucketApproval), ctx, task)
}

// QueryTasks mocks base method.
func (m *MockApprover) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockApproverMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockApprover)(nil).QueryTasks), ctx, subKey)
}

// ReleaseResource mocks base method.
func (m *MockApprover) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockApproverMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockApprover)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockApprover) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockApproverMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockApprover)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockDownloader is a mock of Downloader interface.
type MockDownloader struct {
	ctrl     *gomock.Controller
	recorder *MockDownloaderMockRecorder
}

// MockDownloaderMockRecorder is the mock recorder for MockDownloader.
type MockDownloaderMockRecorder struct {
	mock *MockDownloader
}

// NewMockDownloader creates a new mock instance.
func NewMockDownloader(ctrl *gomock.Controller) *MockDownloader {
	mock := &MockDownloader{ctrl: ctrl}
	mock.recorder = &MockDownloaderMockRecorder{mock}
	return mock
}

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

// HandleChallengePiece mocks base method.
func (m *MockDownloader) HandleChallengePiece(ctx context.Context, task task.ChallengePieceTask) ([]byte, [][]byte, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleChallengePiece", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([][]byte)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// HandleChallengePiece indicates an expected call of HandleChallengePiece.
func (mr *MockDownloaderMockRecorder) HandleChallengePiece(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleChallengePiece", reflect.TypeOf((*MockDownloader)(nil).HandleChallengePiece), ctx, task)
}

// HandleDownloadObjectTask mocks base method.
func (m *MockDownloader) HandleDownloadObjectTask(ctx context.Context, task task.DownloadObjectTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDownloadObjectTask", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleDownloadObjectTask indicates an expected call of HandleDownloadObjectTask.
func (mr *MockDownloaderMockRecorder) HandleDownloadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadObjectTask", reflect.TypeOf((*MockDownloader)(nil).HandleDownloadObjectTask), ctx, task)
}

// HandleDownloadPieceTask mocks base method.
func (m *MockDownloader) HandleDownloadPieceTask(ctx context.Context, task task.DownloadPieceTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDownloadPieceTask", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleDownloadPieceTask indicates an expected call of HandleDownloadPieceTask.
func (mr *MockDownloaderMockRecorder) HandleDownloadPieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadPieceTask", reflect.TypeOf((*MockDownloader)(nil).HandleDownloadPieceTask), ctx, task)
}

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

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

// PostChallengePiece mocks base method.
func (m *MockDownloader) PostChallengePiece(ctx context.Context, task task.ChallengePieceTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostChallengePiece", ctx, task)
}

// PostChallengePiece indicates an expected call of PostChallengePiece.
func (mr *MockDownloaderMockRecorder) PostChallengePiece(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChallengePiece", reflect.TypeOf((*MockDownloader)(nil).PostChallengePiece), ctx, task)
}

// PostDownloadObject mocks base method.
func (m *MockDownloader) PostDownloadObject(ctx context.Context, task task.DownloadObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostDownloadObject", ctx, task)
}

// PostDownloadObject indicates an expected call of PostDownloadObject.
func (mr *MockDownloaderMockRecorder) PostDownloadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDownloadObject", reflect.TypeOf((*MockDownloader)(nil).PostDownloadObject), ctx, task)
}

// PostDownloadPiece mocks base method.
func (m *MockDownloader) PostDownloadPiece(ctx context.Context, task task.DownloadPieceTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostDownloadPiece", ctx, task)
}

// PostDownloadPiece indicates an expected call of PostDownloadPiece.
func (mr *MockDownloaderMockRecorder) PostDownloadPiece(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDownloadPiece", reflect.TypeOf((*MockDownloader)(nil).PostDownloadPiece), ctx, task)
}

// PreChallengePiece mocks base method.
func (m *MockDownloader) PreChallengePiece(ctx context.Context, task task.ChallengePieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreChallengePiece", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreChallengePiece indicates an expected call of PreChallengePiece.
func (mr *MockDownloaderMockRecorder) PreChallengePiece(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreChallengePiece", reflect.TypeOf((*MockDownloader)(nil).PreChallengePiece), ctx, task)
}

// PreDownloadObject mocks base method.
func (m *MockDownloader) PreDownloadObject(ctx context.Context, task task.DownloadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreDownloadObject", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreDownloadObject indicates an expected call of PreDownloadObject.
func (mr *MockDownloaderMockRecorder) PreDownloadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreDownloadObject", reflect.TypeOf((*MockDownloader)(nil).PreDownloadObject), ctx, task)
}

// PreDownloadPiece mocks base method.
func (m *MockDownloader) PreDownloadPiece(ctx context.Context, task task.DownloadPieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreDownloadPiece", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreDownloadPiece indicates an expected call of PreDownloadPiece.
func (mr *MockDownloaderMockRecorder) PreDownloadPiece(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreDownloadPiece", reflect.TypeOf((*MockDownloader)(nil).PreDownloadPiece), ctx, task)
}

// QueryTasks mocks base method.
func (m *MockDownloader) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockDownloaderMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockDownloader)(nil).QueryTasks), ctx, subKey)
}

// ReleaseResource mocks base method.
func (m *MockDownloader) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockDownloaderMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockDownloader)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockDownloader) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockDownloaderMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockDownloader)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockTaskExecutor is a mock of TaskExecutor interface.
type MockTaskExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockTaskExecutorMockRecorder
}

// MockTaskExecutorMockRecorder is the mock recorder for MockTaskExecutor.
type MockTaskExecutorMockRecorder struct {
	mock *MockTaskExecutor
}

// NewMockTaskExecutor creates a new mock instance.
func NewMockTaskExecutor(ctrl *gomock.Controller) *MockTaskExecutor {
	mock := &MockTaskExecutor{ctrl: ctrl}
	mock.recorder = &MockTaskExecutorMockRecorder{mock}
	return mock
}

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

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

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

// HandleGCMetaTask mocks base method.
func (m *MockTaskExecutor) HandleGCMetaTask(ctx context.Context, task task.GCMetaTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleGCMetaTask", ctx, task)
}

// HandleGCMetaTask indicates an expected call of HandleGCMetaTask.
func (mr *MockTaskExecutorMockRecorder) HandleGCMetaTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCMetaTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCMetaTask), ctx, task)
}

// HandleGCObjectTask mocks base method.
func (m *MockTaskExecutor) HandleGCObjectTask(ctx context.Context, task task.GCObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleGCObjectTask", ctx, task)
}

// HandleGCObjectTask indicates an expected call of HandleGCObjectTask.
func (mr *MockTaskExecutorMockRecorder) HandleGCObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCObjectTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCObjectTask), ctx, task)
}

// HandleGCZombiePieceTask mocks base method.
func (m *MockTaskExecutor) HandleGCZombiePieceTask(ctx context.Context, task task.GCZombiePieceTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleGCZombiePieceTask", ctx, task)
}

// HandleGCZombiePieceTask indicates an expected call of HandleGCZombiePieceTask.
func (mr *MockTaskExecutorMockRecorder) HandleGCZombiePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCZombiePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleGCZombiePieceTask), ctx, task)
}

// HandleMigrateGVGTask mocks base method.
func (m *MockTaskExecutor) HandleMigrateGVGTask(ctx context.Context, gvgTask task.MigrateGVGTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleMigrateGVGTask", ctx, gvgTask)
}

// HandleMigrateGVGTask indicates an expected call of HandleMigrateGVGTask.
func (mr *MockTaskExecutorMockRecorder) HandleMigrateGVGTask(ctx, gvgTask any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateGVGTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleMigrateGVGTask), ctx, gvgTask)
}

// HandleReceivePieceTask mocks base method.
func (m *MockTaskExecutor) HandleReceivePieceTask(ctx context.Context, task task.ReceivePieceTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleReceivePieceTask", ctx, task)
}

// HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask.
func (mr *MockTaskExecutorMockRecorder) HandleReceivePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleReceivePieceTask), ctx, task)
}

// HandleReplicatePieceTask mocks base method.
func (m *MockTaskExecutor) HandleReplicatePieceTask(ctx context.Context, task task.ReplicatePieceTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleReplicatePieceTask", ctx, task)
}

// HandleReplicatePieceTask indicates an expected call of HandleReplicatePieceTask.
func (mr *MockTaskExecutorMockRecorder) HandleReplicatePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleReplicatePieceTask), ctx, task)
}

// HandleSealObjectTask mocks base method.
func (m *MockTaskExecutor) HandleSealObjectTask(ctx context.Context, task task.SealObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "HandleSealObjectTask", ctx, task)
}

// HandleSealObjectTask indicates an expected call of HandleSealObjectTask.
func (mr *MockTaskExecutorMockRecorder) HandleSealObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSealObjectTask", reflect.TypeOf((*MockTaskExecutor)(nil).HandleSealObjectTask), ctx, task)
}

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

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

// ReleaseResource mocks base method.
func (m *MockTaskExecutor) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockTaskExecutorMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockTaskExecutor)(nil).ReleaseResource), ctx, scope)
}

// ReportTask mocks base method.
func (m *MockTaskExecutor) ReportTask(ctx context.Context, task task.Task) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReportTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReportTask indicates an expected call of ReportTask.
func (mr *MockTaskExecutorMockRecorder) ReportTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportTask", reflect.TypeOf((*MockTaskExecutor)(nil).ReportTask), ctx, task)
}

// ReserveResource mocks base method.
func (m *MockTaskExecutor) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockTaskExecutorMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockTaskExecutor)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockManager is a mock of Manager interface.
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

// DispatchTask mocks base method.
func (m *MockManager) DispatchTask(ctx context.Context, limit rcmgr.Limit) (task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DispatchTask", ctx, limit)
	ret0, _ := ret[0].(task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DispatchTask indicates an expected call of DispatchTask.
func (mr *MockManagerMockRecorder) DispatchTask(ctx, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchTask", reflect.TypeOf((*MockManager)(nil).DispatchTask), ctx, limit)
}

// HandleChallengePieceTask mocks base method.
func (m *MockManager) HandleChallengePieceTask(ctx context.Context, task task.ChallengePieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleChallengePieceTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleChallengePieceTask indicates an expected call of HandleChallengePieceTask.
func (mr *MockManagerMockRecorder) HandleChallengePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleChallengePieceTask", reflect.TypeOf((*MockManager)(nil).HandleChallengePieceTask), ctx, task)
}

// HandleCreateResumableUploadObjectTask mocks base method.
func (m *MockManager) HandleCreateResumableUploadObjectTask(ctx context.Context, task task.ResumableUploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleCreateResumableUploadObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleCreateResumableUploadObjectTask indicates an expected call of HandleCreateResumableUploadObjectTask.
func (mr *MockManagerMockRecorder) HandleCreateResumableUploadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateResumableUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleCreateResumableUploadObjectTask), ctx, task)
}

// HandleCreateUploadObjectTask mocks base method.
func (m *MockManager) HandleCreateUploadObjectTask(ctx context.Context, task task.UploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleCreateUploadObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleCreateUploadObjectTask indicates an expected call of HandleCreateUploadObjectTask.
func (mr *MockManagerMockRecorder) HandleCreateUploadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCreateUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleCreateUploadObjectTask), ctx, task)
}

// HandleDoneResumableUploadObjectTask mocks base method.
func (m *MockManager) HandleDoneResumableUploadObjectTask(ctx context.Context, task task.ResumableUploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDoneResumableUploadObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleDoneResumableUploadObjectTask indicates an expected call of HandleDoneResumableUploadObjectTask.
func (mr *MockManagerMockRecorder) HandleDoneResumableUploadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneResumableUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDoneResumableUploadObjectTask), ctx, task)
}

// HandleDoneUploadObjectTask mocks base method.
func (m *MockManager) HandleDoneUploadObjectTask(ctx context.Context, task task.UploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDoneUploadObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleDoneUploadObjectTask indicates an expected call of HandleDoneUploadObjectTask.
func (mr *MockManagerMockRecorder) HandleDoneUploadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneUploadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDoneUploadObjectTask), ctx, task)
}

// HandleDownloadObjectTask mocks base method.
func (m *MockManager) HandleDownloadObjectTask(ctx context.Context, task task.DownloadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDownloadObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleDownloadObjectTask indicates an expected call of HandleDownloadObjectTask.
func (mr *MockManagerMockRecorder) HandleDownloadObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDownloadObjectTask", reflect.TypeOf((*MockManager)(nil).HandleDownloadObjectTask), ctx, task)
}

// HandleGCBucketMigrationTask mocks base method.
func (m *MockManager) HandleGCBucketMigrationTask(ctx context.Context, task task.GCBucketMigrationTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleGCBucketMigrationTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleGCBucketMigrationTask indicates an expected call of HandleGCBucketMigrationTask.
func (mr *MockManagerMockRecorder) HandleGCBucketMigrationTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCBucketMigrationTask", reflect.TypeOf((*MockManager)(nil).HandleGCBucketMigrationTask), ctx, task)
}

// HandleGCMetaTask mocks base method.
func (m *MockManager) HandleGCMetaTask(ctx context.Context, task task.GCMetaTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleGCMetaTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleGCMetaTask indicates an expected call of HandleGCMetaTask.
func (mr *MockManagerMockRecorder) HandleGCMetaTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCMetaTask", reflect.TypeOf((*MockManager)(nil).HandleGCMetaTask), ctx, task)
}

// HandleGCObjectTask mocks base method.
func (m *MockManager) HandleGCObjectTask(ctx context.Context, task task.GCObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleGCObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleGCObjectTask indicates an expected call of HandleGCObjectTask.
func (mr *MockManagerMockRecorder) HandleGCObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCObjectTask", reflect.TypeOf((*MockManager)(nil).HandleGCObjectTask), ctx, task)
}

// HandleGCStaleVersionObjectTask mocks base method.
func (m *MockManager) HandleGCStaleVersionObjectTask(ctx context.Context, task task.GCStaleVersionObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleGCStaleVersionObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleGCStaleVersionObjectTask indicates an expected call of HandleGCStaleVersionObjectTask.
func (mr *MockManagerMockRecorder) HandleGCStaleVersionObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCStaleVersionObjectTask", reflect.TypeOf((*MockManager)(nil).HandleGCStaleVersionObjectTask), ctx, task)
}

// HandleGCZombiePieceTask mocks base method.
func (m *MockManager) HandleGCZombiePieceTask(ctx context.Context, task task.GCZombiePieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleGCZombiePieceTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleGCZombiePieceTask indicates an expected call of HandleGCZombiePieceTask.
func (mr *MockManagerMockRecorder) HandleGCZombiePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleGCZombiePieceTask", reflect.TypeOf((*MockManager)(nil).HandleGCZombiePieceTask), ctx, task)
}

// HandleMigrateGVGTask mocks base method.
func (m *MockManager) HandleMigrateGVGTask(ctx context.Context, task task.MigrateGVGTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleMigrateGVGTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleMigrateGVGTask indicates an expected call of HandleMigrateGVGTask.
func (mr *MockManagerMockRecorder) HandleMigrateGVGTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMigrateGVGTask", reflect.TypeOf((*MockManager)(nil).HandleMigrateGVGTask), ctx, task)
}

// HandleReceivePieceTask mocks base method.
func (m *MockManager) HandleReceivePieceTask(ctx context.Context, task task.ReceivePieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleReceivePieceTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask.
func (mr *MockManagerMockRecorder) HandleReceivePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockManager)(nil).HandleReceivePieceTask), ctx, task)
}

// HandleRecoverPieceTask mocks base method.
func (m *MockManager) HandleRecoverPieceTask(ctx context.Context, task task.RecoveryPieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleRecoverPieceTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleRecoverPieceTask indicates an expected call of HandleRecoverPieceTask.
func (mr *MockManagerMockRecorder) HandleRecoverPieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRecoverPieceTask", reflect.TypeOf((*MockManager)(nil).HandleRecoverPieceTask), ctx, task)
}

// HandleReplicatePieceTask mocks base method.
func (m *MockManager) HandleReplicatePieceTask(ctx context.Context, task task.ReplicatePieceTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleReplicatePieceTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleReplicatePieceTask indicates an expected call of HandleReplicatePieceTask.
func (mr *MockManagerMockRecorder) HandleReplicatePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceTask", reflect.TypeOf((*MockManager)(nil).HandleReplicatePieceTask), ctx, task)
}

// HandleSealObjectTask mocks base method.
func (m *MockManager) HandleSealObjectTask(ctx context.Context, task task.SealObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleSealObjectTask", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleSealObjectTask indicates an expected call of HandleSealObjectTask.
func (mr *MockManagerMockRecorder) HandleSealObjectTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSealObjectTask", reflect.TypeOf((*MockManager)(nil).HandleSealObjectTask), ctx, task)
}

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

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

// NotifyMigrateSwapOut mocks base method.
func (m *MockManager) NotifyMigrateSwapOut(ctx context.Context, swapOut *types1.MsgSwapOut) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyMigrateSwapOut", ctx, swapOut)
	ret0, _ := ret[0].(error)
	return ret0
}

// NotifyMigrateSwapOut indicates an expected call of NotifyMigrateSwapOut.
func (mr *MockManagerMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManager)(nil).NotifyMigrateSwapOut), ctx, swapOut)
}

// NotifyPostMigrateBucketAndRecoupQuota mocks base method.
func (m *MockManager) NotifyPostMigrateBucketAndRecoupQuota(ctx context.Context, bmStatus *gfsptask.GfSpBucketMigrationInfo) (*gfsptask.GfSpBucketQuotaInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyPostMigrateBucketAndRecoupQuota", ctx, bmStatus)
	ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotifyPostMigrateBucketAndRecoupQuota indicates an expected call of NotifyPostMigrateBucketAndRecoupQuota.
func (mr *MockManagerMockRecorder) NotifyPostMigrateBucketAndRecoupQuota(ctx, bmStatus any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostMigrateBucketAndRecoupQuota", reflect.TypeOf((*MockManager)(nil).NotifyPostMigrateBucketAndRecoupQuota), ctx, bmStatus)
}

// NotifyPreMigrateBucketAndDeductQuota mocks base method.
func (m *MockManager) NotifyPreMigrateBucketAndDeductQuota(ctx context.Context, bucketID uint64) (*gfsptask.GfSpBucketQuotaInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyPreMigrateBucketAndDeductQuota", ctx, bucketID)
	ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotifyPreMigrateBucketAndDeductQuota indicates an expected call of NotifyPreMigrateBucketAndDeductQuota.
func (mr *MockManagerMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManager)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID)
}

// PickVirtualGroupFamily mocks base method.
func (m *MockManager) PickVirtualGroupFamily(ctx context.Context, task task.ApprovalCreateBucketTask) (uint32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PickVirtualGroupFamily", ctx, task)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PickVirtualGroupFamily indicates an expected call of PickVirtualGroupFamily.
func (mr *MockManagerMockRecorder) PickVirtualGroupFamily(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickVirtualGroupFamily", reflect.TypeOf((*MockManager)(nil).PickVirtualGroupFamily), ctx, task)
}

// QueryBucketMigrate mocks base method.
func (m *MockManager) QueryBucketMigrate(ctx context.Context) (*gfspserver.GfSpQueryBucketMigrateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryBucketMigrate", ctx)
	ret0, _ := ret[0].(*gfspserver.GfSpQueryBucketMigrateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryBucketMigrationProgress mocks base method.
func (m *MockManager) QueryBucketMigrationProgress(ctx context.Context, bucketID uint64) (*gfspserver.MigrateBucketProgressMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryBucketMigrationProgress", ctx, bucketID)
	ret0, _ := ret[0].(*gfspserver.MigrateBucketProgressMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryBucketMigrationProgress indicates an expected call of QueryBucketMigrationProgress.
func (mr *MockManagerMockRecorder) QueryBucketMigrationProgress(ctx, bucketID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryBucketMigrationProgress", reflect.TypeOf((*MockManager)(nil).QueryBucketMigrationProgress), ctx, bucketID)
}

// QueryRecoverProcess mocks base method.
func (m *MockManager) QueryRecoverProcess(ctx context.Context, vgfID, gvgID uint32) ([]*gfspserver.RecoverProcess, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRecoverProcess", ctx, vgfID, gvgID)
	ret0, _ := ret[0].([]*gfspserver.RecoverProcess)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryRecoverProcess indicates an expected call of QueryRecoverProcess.
func (mr *MockManagerMockRecorder) QueryRecoverProcess(ctx, vgfID, gvgID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRecoverProcess", reflect.TypeOf((*MockManager)(nil).QueryRecoverProcess), ctx, vgfID, gvgID)
}

// QuerySpExit mocks base method.
func (m *MockManager) QuerySpExit(ctx context.Context) (*gfspserver.GfSpQuerySpExitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySpExit", ctx)
	ret0, _ := ret[0].(*gfspserver.GfSpQuerySpExitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryTasks mocks base method.
func (m *MockManager) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockManagerMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockManager)(nil).QueryTasks), ctx, subKey)
}

// QueryTasksStats mocks base method.
func (m *MockManager) QueryTasksStats(ctx context.Context) (int, int, int, int, int, int, int, []string) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasksStats", ctx)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(int)
	ret3, _ := ret[3].(int)
	ret4, _ := ret[4].(int)
	ret5, _ := ret[5].(int)
	ret6, _ := ret[6].(int)
	ret7, _ := ret[7].([]string)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6, ret7
}

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

// ReleaseResource mocks base method.
func (m *MockManager) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockManagerMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockManager)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockManager) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockManagerMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockManager)(nil).ReserveResource), ctx, state)
}

// ResetRecoveryFailedList mocks base method.
func (m *MockManager) ResetRecoveryFailedList(ctx context.Context) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetRecoveryFailedList", ctx)
	ret0, _ := ret[0].([]string)
	return ret0
}

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

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

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

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

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

// TriggerRecoverForSuccessorSP mocks base method.
func (m *MockManager) TriggerRecoverForSuccessorSP(ctx context.Context, vgfID, gvgID uint32, redundancyIndex int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TriggerRecoverForSuccessorSP", ctx, vgfID, gvgID, redundancyIndex)
	ret0, _ := ret[0].(error)
	return ret0
}

// TriggerRecoverForSuccessorSP indicates an expected call of TriggerRecoverForSuccessorSP.
func (mr *MockManagerMockRecorder) TriggerRecoverForSuccessorSP(ctx, vgfID, gvgID, redundancyIndex any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TriggerRecoverForSuccessorSP", reflect.TypeOf((*MockManager)(nil).TriggerRecoverForSuccessorSP), ctx, vgfID, gvgID, redundancyIndex)
}

// MockP2P is a mock of P2P interface.
type MockP2P struct {
	ctrl     *gomock.Controller
	recorder *MockP2PMockRecorder
}

// MockP2PMockRecorder is the mock recorder for MockP2P.
type MockP2PMockRecorder struct {
	mock *MockP2P
}

// NewMockP2P creates a new mock instance.
func NewMockP2P(ctrl *gomock.Controller) *MockP2P {
	mock := &MockP2P{ctrl: ctrl}
	mock.recorder = &MockP2PMockRecorder{mock}
	return mock
}

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

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

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

// HandleReplicatePieceApproval mocks base method.
func (m *MockP2P) HandleReplicatePieceApproval(ctx context.Context, t task.ApprovalReplicatePieceTask, min, max int32, timeout int64) ([]task.ApprovalReplicatePieceTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleReplicatePieceApproval", ctx, t, min, max, timeout)
	ret0, _ := ret[0].([]task.ApprovalReplicatePieceTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleReplicatePieceApproval indicates an expected call of HandleReplicatePieceApproval.
func (mr *MockP2PMockRecorder) HandleReplicatePieceApproval(ctx, t, min, max, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReplicatePieceApproval", reflect.TypeOf((*MockP2P)(nil).HandleReplicatePieceApproval), ctx, t, min, max, timeout)
}

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

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

// QueryTasks mocks base method.
func (m *MockP2P) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockP2PMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockP2P)(nil).QueryTasks), ctx, subKey)
}

// ReleaseResource mocks base method.
func (m *MockP2P) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockP2PMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockP2P)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockP2P) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockP2PMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockP2P)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockReceiver is a mock of Receiver interface.
type MockReceiver struct {
	ctrl     *gomock.Controller
	recorder *MockReceiverMockRecorder
}

// MockReceiverMockRecorder is the mock recorder for MockReceiver.
type MockReceiverMockRecorder struct {
	mock *MockReceiver
}

// NewMockReceiver creates a new mock instance.
func NewMockReceiver(ctrl *gomock.Controller) *MockReceiver {
	mock := &MockReceiver{ctrl: ctrl}
	mock.recorder = &MockReceiverMockRecorder{mock}
	return mock
}

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

// HandleDoneReceivePieceTask mocks base method.
func (m *MockReceiver) HandleDoneReceivePieceTask(ctx context.Context, task task.ReceivePieceTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleDoneReceivePieceTask", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleDoneReceivePieceTask indicates an expected call of HandleDoneReceivePieceTask.
func (mr *MockReceiverMockRecorder) HandleDoneReceivePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleDoneReceivePieceTask", reflect.TypeOf((*MockReceiver)(nil).HandleDoneReceivePieceTask), ctx, task)
}

// HandleReceivePieceTask mocks base method.
func (m *MockReceiver) HandleReceivePieceTask(ctx context.Context, task task.ReceivePieceTask, data []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleReceivePieceTask", ctx, task, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleReceivePieceTask indicates an expected call of HandleReceivePieceTask.
func (mr *MockReceiverMockRecorder) HandleReceivePieceTask(ctx, task, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleReceivePieceTask", reflect.TypeOf((*MockReceiver)(nil).HandleReceivePieceTask), ctx, task, data)
}

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

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

// QueryTasks mocks base method.
func (m *MockReceiver) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockReceiverMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockReceiver)(nil).QueryTasks), ctx, subKey)
}

// ReleaseResource mocks base method.
func (m *MockReceiver) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockReceiverMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockReceiver)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockReceiver) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockReceiverMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockReceiver)(nil).ReserveResource), ctx, state)
}

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

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

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

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

// MockSigner is a mock of Signer interface.
type MockSigner struct {
	ctrl     *gomock.Controller
	recorder *MockSignerMockRecorder
}

// MockSignerMockRecorder is the mock recorder for MockSigner.
type MockSignerMockRecorder struct {
	mock *MockSigner
}

// NewMockSigner creates a new mock instance.
func NewMockSigner(ctrl *gomock.Controller) *MockSigner {
	mock := &MockSigner{ctrl: ctrl}
	mock.recorder = &MockSignerMockRecorder{mock}
	return mock
}

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

// CancelSwapIn mocks base method.
func (m *MockSigner) CancelSwapIn(ctx context.Context, cancelSwapIn *types1.MsgCancelSwapIn) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelSwapIn", ctx, cancelSwapIn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelSwapIn indicates an expected call of CancelSwapIn.
func (mr *MockSignerMockRecorder) CancelSwapIn(ctx, cancelSwapIn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSwapIn", reflect.TypeOf((*MockSigner)(nil).CancelSwapIn), ctx, cancelSwapIn)
}

// CompleteMigrateBucket mocks base method.
func (m *MockSigner) CompleteMigrateBucket(ctx context.Context, migrateBucket *types0.MsgCompleteMigrateBucket) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteMigrateBucket", ctx, migrateBucket)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteMigrateBucket indicates an expected call of CompleteMigrateBucket.
func (mr *MockSignerMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockSigner)(nil).CompleteMigrateBucket), ctx, migrateBucket)
}

// CompleteSPExit mocks base method.
func (m *MockSigner) CompleteSPExit(ctx context.Context, completeSPExit *types1.MsgCompleteStorageProviderExit) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteSPExit", ctx, completeSPExit)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteSPExit indicates an expected call of CompleteSPExit.
func (mr *MockSignerMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockSigner)(nil).CompleteSPExit), ctx, completeSPExit)
}

// CompleteSwapIn mocks base method.
func (m *MockSigner) CompleteSwapIn(ctx context.Context, reserveSwapIn *types1.MsgCompleteSwapIn) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteSwapIn", ctx, reserveSwapIn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteSwapIn indicates an expected call of CompleteSwapIn.
func (mr *MockSignerMockRecorder) CompleteSwapIn(ctx, reserveSwapIn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapIn", reflect.TypeOf((*MockSigner)(nil).CompleteSwapIn), ctx, reserveSwapIn)
}

// CompleteSwapOut mocks base method.
func (m *MockSigner) CompleteSwapOut(ctx context.Context, completeSwapOut *types1.MsgCompleteSwapOut) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteSwapOut", ctx, completeSwapOut)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteSwapOut indicates an expected call of CompleteSwapOut.
func (mr *MockSignerMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockSigner)(nil).CompleteSwapOut), ctx, completeSwapOut)
}

// CreateGlobalVirtualGroup mocks base method.
func (m *MockSigner) CreateGlobalVirtualGroup(ctx context.Context, gvg *types1.MsgCreateGlobalVirtualGroup) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGlobalVirtualGroup", ctx, gvg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGlobalVirtualGroup indicates an expected call of CreateGlobalVirtualGroup.
func (mr *MockSignerMockRecorder) CreateGlobalVirtualGroup(ctx, gvg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).CreateGlobalVirtualGroup), ctx, gvg)
}

// DelegateCreateObject mocks base method.
func (m *MockSigner) DelegateCreateObject(ctx context.Context, msg *types0.MsgDelegateCreateObject) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DelegateCreateObject", ctx, msg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DelegateCreateObject indicates an expected call of DelegateCreateObject.
func (mr *MockSignerMockRecorder) DelegateCreateObject(ctx, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateCreateObject", reflect.TypeOf((*MockSigner)(nil).DelegateCreateObject), ctx, msg)
}

// DelegateUpdateObjectContent mocks base method.
func (m *MockSigner) DelegateUpdateObjectContent(ctx context.Context, msg *types0.MsgDelegateUpdateObjectContent) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DelegateUpdateObjectContent", ctx, msg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DelegateUpdateObjectContent indicates an expected call of DelegateUpdateObjectContent.
func (mr *MockSignerMockRecorder) DelegateUpdateObjectContent(ctx, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelegateUpdateObjectContent", reflect.TypeOf((*MockSigner)(nil).DelegateUpdateObjectContent), ctx, msg)
}

// DeleteGlobalVirtualGroup mocks base method.
func (m *MockSigner) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *types1.MsgDeleteGlobalVirtualGroup) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGlobalVirtualGroup", ctx, deleteGVG)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGlobalVirtualGroup indicates an expected call of DeleteGlobalVirtualGroup.
func (mr *MockSignerMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSigner)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG)
}

// Deposit mocks base method.
func (m *MockSigner) Deposit(ctx context.Context, deposit *types1.MsgDeposit) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deposit", ctx, deposit)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Deposit indicates an expected call of Deposit.
func (mr *MockSignerMockRecorder) Deposit(ctx, deposit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSigner)(nil).Deposit), ctx, deposit)
}

// DiscontinueBucket mocks base method.
func (m *MockSigner) DiscontinueBucket(ctx context.Context, bucket *types0.MsgDiscontinueBucket) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiscontinueBucket", ctx, bucket)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiscontinueBucket indicates an expected call of DiscontinueBucket.
func (mr *MockSignerMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockSigner)(nil).DiscontinueBucket), ctx, bucket)
}

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

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

// RejectMigrateBucket mocks base method.
func (m *MockSigner) RejectMigrateBucket(ctx context.Context, rejectMigrateBucket *types0.MsgRejectMigrateBucket) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectMigrateBucket", ctx, rejectMigrateBucket)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectMigrateBucket indicates an expected call of RejectMigrateBucket.
func (mr *MockSignerMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockSigner)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket)
}

// RejectUnSealObject mocks base method.
func (m *MockSigner) RejectUnSealObject(ctx context.Context, object *types0.MsgRejectSealObject) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RejectUnSealObject", ctx, object)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RejectUnSealObject indicates an expected call of RejectUnSealObject.
func (mr *MockSignerMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockSigner)(nil).RejectUnSealObject), ctx, object)
}

// ReleaseResource mocks base method.
func (m *MockSigner) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockSignerMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockSigner)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockSigner) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockSignerMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockSigner)(nil).ReserveResource), ctx, state)
}

// ReserveSwapIn mocks base method.
func (m *MockSigner) ReserveSwapIn(ctx context.Context, reserveSwapIn *types1.MsgReserveSwapIn) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveSwapIn", ctx, reserveSwapIn)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveSwapIn indicates an expected call of ReserveSwapIn.
func (mr *MockSignerMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockSigner)(nil).ReserveSwapIn), ctx, reserveSwapIn)
}

// SPExit mocks base method.
func (m *MockSigner) SPExit(ctx context.Context, spExit *types1.MsgStorageProviderExit) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPExit", ctx, spExit)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SPExit indicates an expected call of SPExit.
func (mr *MockSignerMockRecorder) SPExit(ctx, spExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockSigner)(nil).SPExit), ctx, spExit)
}

// SealObject mocks base method.
func (m *MockSigner) SealObject(ctx context.Context, object *types0.MsgSealObject) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealObject", ctx, object)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SealObject indicates an expected call of SealObject.
func (mr *MockSignerMockRecorder) SealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockSigner)(nil).SealObject), ctx, object)
}

// SealObjectV2 mocks base method.
func (m *MockSigner) SealObjectV2(ctx context.Context, object *types0.MsgSealObjectV2) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SealObjectV2", ctx, object)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SealObjectV2 indicates an expected call of SealObjectV2.
func (mr *MockSignerMockRecorder) SealObjectV2(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObjectV2", reflect.TypeOf((*MockSigner)(nil).SealObjectV2), ctx, object)
}

// SignBucketMigrationInfo mocks base method.
func (m *MockSigner) SignBucketMigrationInfo(ctx context.Context, task *gfsptask.GfSpBucketMigrationInfo) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignBucketMigrationInfo", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignBucketMigrationInfo indicates an expected call of SignBucketMigrationInfo.
func (mr *MockSignerMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockSigner)(nil).SignBucketMigrationInfo), ctx, task)
}

// SignCreateBucketApproval mocks base method.
func (m *MockSigner) SignCreateBucketApproval(ctx context.Context, bucket *types0.MsgCreateBucket) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignCreateBucketApproval", ctx, bucket)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignCreateBucketApproval indicates an expected call of SignCreateBucketApproval.
func (mr *MockSignerMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockSigner)(nil).SignCreateBucketApproval), ctx, bucket)
}

// SignCreateObjectApproval mocks base method.
func (m *MockSigner) SignCreateObjectApproval(ctx context.Context, task *types0.MsgCreateObject) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignCreateObjectApproval", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignCreateObjectApproval indicates an expected call of SignCreateObjectApproval.
func (mr *MockSignerMockRecorder) SignCreateObjectApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateObjectApproval", reflect.TypeOf((*MockSigner)(nil).SignCreateObjectApproval), ctx, task)
}

// SignMigrateBucketApproval mocks base method.
func (m *MockSigner) SignMigrateBucketApproval(ctx context.Context, bucket *types0.MsgMigrateBucket) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignMigrateBucketApproval", ctx, bucket)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignMigrateBucketApproval indicates an expected call of SignMigrateBucketApproval.
func (mr *MockSignerMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockSigner)(nil).SignMigrateBucketApproval), ctx, bucket)
}

// SignMigrateGVG mocks base method.
func (m *MockSigner) SignMigrateGVG(ctx context.Context, task *gfsptask.GfSpMigrateGVGTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignMigrateGVG", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignMigrateGVG indicates an expected call of SignMigrateGVG.
func (mr *MockSignerMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockSigner)(nil).SignMigrateGVG), ctx, task)
}

// SignP2PPingMsg mocks base method.
func (m *MockSigner) SignP2PPingMsg(ctx context.Context, ping *gfspp2p.GfSpPing) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignP2PPingMsg", ctx, ping)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignP2PPingMsg indicates an expected call of SignP2PPingMsg.
func (mr *MockSignerMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockSigner)(nil).SignP2PPingMsg), ctx, ping)
}

// SignP2PPongMsg mocks base method.
func (m *MockSigner) SignP2PPongMsg(ctx context.Context, pong *gfspp2p.GfSpPong) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignP2PPongMsg", ctx, pong)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignP2PPongMsg indicates an expected call of SignP2PPongMsg.
func (mr *MockSignerMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockSigner)(nil).SignP2PPongMsg), ctx, pong)
}

// SignReceivePieceTask mocks base method.
func (m *MockSigner) SignReceivePieceTask(ctx context.Context, task task.ReceivePieceTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignReceivePieceTask", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignReceivePieceTask indicates an expected call of SignReceivePieceTask.
func (mr *MockSignerMockRecorder) SignReceivePieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReceivePieceTask", reflect.TypeOf((*MockSigner)(nil).SignReceivePieceTask), ctx, task)
}

// SignRecoveryPieceTask mocks base method.
func (m *MockSigner) SignRecoveryPieceTask(ctx context.Context, task task.RecoveryPieceTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignRecoveryPieceTask", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignRecoveryPieceTask indicates an expected call of SignRecoveryPieceTask.
func (mr *MockSignerMockRecorder) SignRecoveryPieceTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignRecoveryPieceTask", reflect.TypeOf((*MockSigner)(nil).SignRecoveryPieceTask), ctx, task)
}

// SignReplicatePieceApproval mocks base method.
func (m *MockSigner) SignReplicatePieceApproval(ctx context.Context, task task.ApprovalReplicatePieceTask) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignReplicatePieceApproval", ctx, task)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignReplicatePieceApproval indicates an expected call of SignReplicatePieceApproval.
func (mr *MockSignerMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockSigner)(nil).SignReplicatePieceApproval), ctx, task)
}

// SignSecondarySPMigrationBucket mocks base method.
func (m *MockSigner) SignSecondarySPMigrationBucket(ctx context.Context, signDoc *types0.SecondarySpMigrationBucketSignDoc) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignSecondarySPMigrationBucket", ctx, signDoc)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignSecondarySPMigrationBucket indicates an expected call of SignSecondarySPMigrationBucket.
func (mr *MockSignerMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockSigner)(nil).SignSecondarySPMigrationBucket), ctx, signDoc)
}

// SignSecondarySealBls mocks base method.
func (m *MockSigner) SignSecondarySealBls(ctx context.Context, objectID uint64, gvgId uint32, hash [][]byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignSecondarySealBls", ctx, objectID, gvgId, hash)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignSecondarySealBls indicates an expected call of SignSecondarySealBls.
func (mr *MockSignerMockRecorder) SignSecondarySealBls(ctx, objectID, gvgId, hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySealBls", reflect.TypeOf((*MockSigner)(nil).SignSecondarySealBls), ctx, objectID, gvgId, hash)
}

// SignSwapOut mocks base method.
func (m *MockSigner) SignSwapOut(ctx context.Context, swapOut *types1.MsgSwapOut) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignSwapOut", ctx, swapOut)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignSwapOut indicates an expected call of SignSwapOut.
func (mr *MockSignerMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockSigner)(nil).SignSwapOut), ctx, swapOut)
}

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

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

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

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

// SwapOut mocks base method.
func (m *MockSigner) SwapOut(ctx context.Context, swapOut *types1.MsgSwapOut) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SwapOut", ctx, swapOut)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwapOut indicates an expected call of SwapOut.
func (mr *MockSignerMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockSigner)(nil).SwapOut), ctx, swapOut)
}

// UpdateSPPrice mocks base method.
func (m *MockSigner) UpdateSPPrice(ctx context.Context, price *types.MsgUpdateSpStoragePrice) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSPPrice", ctx, price)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSPPrice indicates an expected call of UpdateSPPrice.
func (mr *MockSignerMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockSigner)(nil).UpdateSPPrice), ctx, price)
}

// MockUploader is a mock of Uploader interface.
type MockUploader struct {
	ctrl     *gomock.Controller
	recorder *MockUploaderMockRecorder
}

// MockUploaderMockRecorder is the mock recorder for MockUploader.
type MockUploaderMockRecorder struct {
	mock *MockUploader
}

// NewMockUploader creates a new mock instance.
func NewMockUploader(ctrl *gomock.Controller) *MockUploader {
	mock := &MockUploader{ctrl: ctrl}
	mock.recorder = &MockUploaderMockRecorder{mock}
	return mock
}

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

// HandleResumableUploadObjectTask mocks base method.
func (m *MockUploader) HandleResumableUploadObjectTask(ctx context.Context, task task.ResumableUploadObjectTask, stream io.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleResumableUploadObjectTask", ctx, task, stream)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleResumableUploadObjectTask indicates an expected call of HandleResumableUploadObjectTask.
func (mr *MockUploaderMockRecorder) HandleResumableUploadObjectTask(ctx, task, stream any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResumableUploadObjectTask", reflect.TypeOf((*MockUploader)(nil).HandleResumableUploadObjectTask), ctx, task, stream)
}

// HandleUploadObjectTask mocks base method.
func (m *MockUploader) HandleUploadObjectTask(ctx context.Context, task task.UploadObjectTask, stream io.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleUploadObjectTask", ctx, task, stream)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleUploadObjectTask indicates an expected call of HandleUploadObjectTask.
func (mr *MockUploaderMockRecorder) HandleUploadObjectTask(ctx, task, stream any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleUploadObjectTask", reflect.TypeOf((*MockUploader)(nil).HandleUploadObjectTask), ctx, task, stream)
}

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

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

// PostResumableUploadObject mocks base method.
func (m *MockUploader) PostResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostResumableUploadObject", ctx, task)
}

// PostResumableUploadObject indicates an expected call of PostResumableUploadObject.
func (mr *MockUploaderMockRecorder) PostResumableUploadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostResumableUploadObject", reflect.TypeOf((*MockUploader)(nil).PostResumableUploadObject), ctx, task)
}

// PostUploadObject mocks base method.
func (m *MockUploader) PostUploadObject(ctx context.Context, task task.UploadObjectTask) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PostUploadObject", ctx, task)
}

// PostUploadObject indicates an expected call of PostUploadObject.
func (mr *MockUploaderMockRecorder) PostUploadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostUploadObject", reflect.TypeOf((*MockUploader)(nil).PostUploadObject), ctx, task)
}

// PreResumableUploadObject mocks base method.
func (m *MockUploader) PreResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreResumableUploadObject", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreResumableUploadObject indicates an expected call of PreResumableUploadObject.
func (mr *MockUploaderMockRecorder) PreResumableUploadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreResumableUploadObject", reflect.TypeOf((*MockUploader)(nil).PreResumableUploadObject), ctx, task)
}

// PreUploadObject mocks base method.
func (m *MockUploader) PreUploadObject(ctx context.Context, task task.UploadObjectTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreUploadObject", ctx, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// PreUploadObject indicates an expected call of PreUploadObject.
func (mr *MockUploaderMockRecorder) PreUploadObject(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreUploadObject", reflect.TypeOf((*MockUploader)(nil).PreUploadObject), ctx, task)
}

// QueryTasks mocks base method.
func (m *MockUploader) QueryTasks(ctx context.Context, subKey task.TKey) ([]task.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTasks", ctx, subKey)
	ret0, _ := ret[0].([]task.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTasks indicates an expected call of QueryTasks.
func (mr *MockUploaderMockRecorder) QueryTasks(ctx, subKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTasks", reflect.TypeOf((*MockUploader)(nil).QueryTasks), ctx, subKey)
}

// ReleaseResource mocks base method.
func (m *MockUploader) ReleaseResource(ctx context.Context, scope rcmgr.ResourceScopeSpan) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResource", ctx, scope)
}

// ReleaseResource indicates an expected call of ReleaseResource.
func (mr *MockUploaderMockRecorder) ReleaseResource(ctx, scope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseResource", reflect.TypeOf((*MockUploader)(nil).ReleaseResource), ctx, scope)
}

// ReserveResource mocks base method.
func (m *MockUploader) ReserveResource(ctx context.Context, state *rcmgr.ScopeStat) (rcmgr.ResourceScopeSpan, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReserveResource", ctx, state)
	ret0, _ := ret[0].(rcmgr.ResourceScopeSpan)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReserveResource indicates an expected call of ReserveResource.
func (mr *MockUploaderMockRecorder) ReserveResource(ctx, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveResource", reflect.TypeOf((*MockUploader)(nil).ReserveResource), ctx, state)
}

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

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

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

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