// Code generated by MockGen. DO NOT EDIT.
// Source: ./interface.go
//
// Generated by this command:
//
//	mockgen -source=./interface.go -destination=./interface_mock.go -package=gfspclient
//

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

import (
	context "context"
	io "io"
	http "net/http"
	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"
	module "github.com/bnb-chain/greenfield-storage-provider/core/module"
	rcmgr "github.com/bnb-chain/greenfield-storage-provider/core/rcmgr"
	task "github.com/bnb-chain/greenfield-storage-provider/core/task"
	types "github.com/bnb-chain/greenfield-storage-provider/modular/metadata/types"
	resource "github.com/bnb-chain/greenfield/types/resource"
	types0 "github.com/bnb-chain/greenfield/x/payment/types"
	types1 "github.com/bnb-chain/greenfield/x/permission/types"
	types2 "github.com/bnb-chain/greenfield/x/sp/types"
	types3 "github.com/bnb-chain/greenfield/x/storage/types"
	types4 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockGfSpClientAPI is a mock of GfSpClientAPI interface.
type MockGfSpClientAPI struct {
	ctrl     *gomock.Controller
	recorder *MockGfSpClientAPIMockRecorder
}

// MockGfSpClientAPIMockRecorder is the mock recorder for MockGfSpClientAPI.
type MockGfSpClientAPIMockRecorder struct {
	mock *MockGfSpClientAPI
}

// NewMockGfSpClientAPI creates a new mock instance.
func NewMockGfSpClientAPI(ctrl *gomock.Controller) *MockGfSpClientAPI {
	mock := &MockGfSpClientAPI{ctrl: ctrl}
	mock.recorder = &MockGfSpClientAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// AskSecondaryReplicatePieceApproval mocks base method.
func (m *MockGfSpClientAPI) AskSecondaryReplicatePieceApproval(ctx context.Context, task task.ApprovalReplicatePieceTask, low, high int, timeout int64) ([]*gfsptask.GfSpReplicatePieceApprovalTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AskSecondaryReplicatePieceApproval", ctx, task, low, high, timeout)
	ret0, _ := ret[0].([]*gfsptask.GfSpReplicatePieceApprovalTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AskSecondaryReplicatePieceApproval indicates an expected call of AskSecondaryReplicatePieceApproval.
func (mr *MockGfSpClientAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskSecondaryReplicatePieceApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).AskSecondaryReplicatePieceApproval), ctx, task, low, high, timeout)
}

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

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

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

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

// CompleteMigrateBucket mocks base method.
func (m *MockGfSpClientAPI) CompleteMigrateBucket(ctx context.Context, migrateBucket *types3.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 *MockGfSpClientAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteMigrateBucket), ctx, migrateBucket)
}

// CompleteSPExit mocks base method.
func (m *MockGfSpClientAPI) CompleteSPExit(ctx context.Context, completeSPExit *types4.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 *MockGfSpClientAPIMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteSPExit), ctx, completeSPExit)
}

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

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

// CompleteSwapOut mocks base method.
func (m *MockGfSpClientAPI) CompleteSwapOut(ctx context.Context, completeSwapOut *types4.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 *MockGfSpClientAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).CompleteSwapOut), ctx, completeSwapOut)
}

// Connection mocks base method.
func (m *MockGfSpClientAPI) Connection(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, address}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Connection", varargs...)
	ret0, _ := ret[0].(*grpc.ClientConn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// DeductQuotaForBucketMigrate mocks base method.
func (m *MockGfSpClientAPI) DeductQuotaForBucketMigrate(ctx context.Context, bucketID, deductQuota uint64, yearMonth string, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, deductQuota, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeductQuotaForBucketMigrate", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// DeleteAuthKeysV2 mocks base method.
func (m *MockGfSpClientAPI) DeleteAuthKeysV2(ctx context.Context, account, domain string, userPublicKeys []string, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKeys}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAuthKeysV2", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGlobalVirtualGroup mocks base method.
func (m *MockGfSpClientAPI) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *types4.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 *MockGfSpClientAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockGfSpClientAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG)
}

// Deposit mocks base method.
func (m *MockGfSpClientAPI) Deposit(ctx context.Context, deposit *types4.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 *MockGfSpClientAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockGfSpClientAPI)(nil).Deposit), ctx, deposit)
}

// DiscontinueBucket mocks base method.
func (m *MockGfSpClientAPI) DiscontinueBucket(ctx context.Context, bucket *types3.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 *MockGfSpClientAPIMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).DiscontinueBucket), ctx, bucket)
}

// DoneReplicatePiece mocks base method.
func (m *MockGfSpClientAPI) DoneReplicatePiece(ctx context.Context, task task.ReceivePieceTask, opts ...grpc.DialOption) ([]byte, []byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DoneReplicatePiece", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

// DoneReplicatePieceToSecondary indicates an expected call of DoneReplicatePieceToSecondary.
func (mr *MockGfSpClientAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePieceToSecondary", reflect.TypeOf((*MockGfSpClientAPI)(nil).DoneReplicatePieceToSecondary), ctx, endpoint, receive)
}

// GetAuthKeyV2 mocks base method.
func (m *MockGfSpClientAPI) GetAuthKeyV2(ctx context.Context, account, domain, userPublicKey string, opts ...grpc.DialOption) (string, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuthKeyV2", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetAuthNonce mocks base method.
func (m *MockGfSpClientAPI) GetAuthNonce(ctx context.Context, account, domain string, opts ...grpc.DialOption) (int32, int32, string, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuthNonce", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(int32)
	ret2, _ := ret[2].(string)
	ret3, _ := ret[3].(int64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// GetBsDBInfo mocks base method.
func (m *MockGfSpClientAPI) GetBsDBInfo(ctx context.Context, blockHeight uint64, opts ...grpc.DialOption) (*types.GfSpGetBsDBInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockHeight}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBsDBInfo", varargs...)
	ret0, _ := ret[0].(*types.GfSpGetBsDBInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketByBucketID mocks base method.
func (m *MockGfSpClientAPI) GetBucketByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketByBucketID", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketByBucketName mocks base method.
func (m *MockGfSpClientAPI) GetBucketByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketByBucketName", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketInfoByBucketName mocks base method.
func (m *MockGfSpClientAPI) GetBucketInfoByBucketName(ctx context.Context, bucketName string, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketInfoByBucketName", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketMeta mocks base method.
func (m *MockGfSpClientAPI) GetBucketMeta(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.VGFInfoBucket, *types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketMeta", varargs...)
	ret0, _ := ret[0].(*types.VGFInfoBucket)
	ret1, _ := ret[1].(*types0.StreamRecord)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetBucketReadQuota mocks base method.
func (m *MockGfSpClientAPI) GetBucketReadQuota(ctx context.Context, bucket *types3.BucketInfo, yearMonth string, opts ...grpc.DialOption) (uint64, uint64, uint64, uint64, uint64, uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucket, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketReadQuota", varargs...)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(uint64)
	ret4, _ := ret[4].(uint64)
	ret5, _ := ret[5].(uint64)
	ret6, _ := ret[6].(error)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6
}

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

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

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

// GetBucketSize mocks base method.
func (m *MockGfSpClientAPI) GetBucketSize(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketSize", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChallengeInfo mocks base method.
func (m *MockGfSpClientAPI) GetChallengeInfo(ctx context.Context, challengePieceTask task.ChallengePieceTask, opts ...grpc.DialOption) ([]byte, [][]byte, []byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, challengePieceTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChallengeInfo", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([][]byte)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// GetEndpointBySpID mocks base method.
func (m *MockGfSpClientAPI) GetEndpointBySpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEndpointBySpID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGlobalVirtualGroup mocks base method.
func (m *MockGfSpClientAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID uint64, lvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, lvgID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalVirtualGroup", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGlobalVirtualGroupByGvgID mocks base method.
func (m *MockGfSpClientAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalVirtualGroupByGvgID", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupList mocks base method.
func (m *MockGfSpClientAPI) GetGroupList(ctx context.Context, name, prefix, sourceType string, limit, offset int64, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Group, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupList", varargs...)
	ret0, _ := ret[0].([]*types.Group)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGroupList indicates an expected call of GetGroupList.
func (mr *MockGfSpClientAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupList", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetGroupList), varargs...)
}

// GetGroupMembers mocks base method.
func (m *MockGfSpClientAPI) GetGroupMembers(ctx context.Context, groupID uint64, startAfter string, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, groupID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupMembers", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestBucketReadQuota mocks base method.
func (m *MockGfSpClientAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLatestBucketReadQuota", varargs...)
	ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// GetObject mocks base method.
func (m *MockGfSpClientAPI) GetObject(ctx context.Context, downloadObjectTask task.DownloadObjectTask, opts ...grpc.DialOption) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, downloadObjectTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObject", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetObjectByID mocks base method.
func (m *MockGfSpClientAPI) GetObjectByID(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (*types3.ObjectInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectByID", varargs...)
	ret0, _ := ret[0].(*types3.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetObjectMeta mocks base method.
func (m *MockGfSpClientAPI) GetObjectMeta(ctx context.Context, objectName, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Object, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectName, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectMeta", varargs...)
	ret0, _ := ret[0].(*types.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPaymentByBucketID mocks base method.
func (m *MockGfSpClientAPI) GetPaymentByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPaymentByBucketID", varargs...)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPaymentByBucketName mocks base method.
func (m *MockGfSpClientAPI) GetPaymentByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPaymentByBucketName", varargs...)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPiece mocks base method.
func (m *MockGfSpClientAPI) GetPiece(ctx context.Context, downloadPieceTask task.DownloadPieceTask, opts ...grpc.DialOption) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, downloadPieceTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPiece", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPieceFromECChunks mocks base method.
func (m *MockGfSpClientAPI) GetPieceFromECChunks(ctx context.Context, endpoint string, task task.RecoveryPieceTask) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPieceFromECChunks", ctx, endpoint, task)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSPInfo mocks base method.
func (m *MockGfSpClientAPI) GetSPInfo(ctx context.Context, operatorAddress string, opts ...grpc.DialOption) (*types2.StorageProvider, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, operatorAddress}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSPInfo", varargs...)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSPMigratingBucketNumber mocks base method.
func (m *MockGfSpClientAPI) GetSPMigratingBucketNumber(ctx context.Context, spID uint32, opts ...grpc.DialOption) (uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSPMigratingBucketNumber", varargs...)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetStatus mocks base method.
func (m *MockGfSpClientAPI) GetStatus(ctx context.Context, opts ...grpc.DialOption) (*types.Status, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStatus", varargs...)
	ret0, _ := ret[0].(*types.Status)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// GetSwapOutApproval indicates an expected call of GetSwapOutApproval.
func (mr *MockGfSpClientAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSwapOutApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).GetSwapOutApproval), ctx, destSPEndpoint, swapOutApproval)
}

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

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

// GetUploadObjectSegment mocks base method.
func (m *MockGfSpClientAPI) GetUploadObjectSegment(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (uint32, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUploadObjectSegment", varargs...)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUploadObjectState mocks base method.
func (m *MockGfSpClientAPI) GetUploadObjectState(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (int32, string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUploadObjectState", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetUserBuckets mocks base method.
func (m *MockGfSpClientAPI) GetUserBuckets(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.VGFInfoBucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserBuckets", varargs...)
	ret0, _ := ret[0].([]*types.VGFInfoBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserBucketsCount mocks base method.
func (m *MockGfSpClientAPI) GetUserBucketsCount(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserBucketsCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserGroups mocks base method.
func (m *MockGfSpClientAPI) GetUserGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserGroups", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserOwnedGroups mocks base method.
func (m *MockGfSpClientAPI) GetUserOwnedGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserOwnedGroups", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVirtualGroupFamily mocks base method.
func (m *MockGfSpClientAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroupFamily, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, vgfID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVirtualGroupFamily", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ListAuthKeysV2 mocks base method.
func (m *MockGfSpClientAPI) ListAuthKeysV2(ctx context.Context, account, domain string, opts ...grpc.DialOption) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAuthKeysV2", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBucketReadQuota mocks base method.
func (m *MockGfSpClientAPI) ListBucketReadQuota(ctx context.Context, yearMonth string, offset, limit uint32, opts ...grpc.DialOption) ([]*types.BucketReadQuotaRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, yearMonth, offset, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketReadQuota", varargs...)
	ret0, _ := ret[0].([]*types.BucketReadQuotaRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBucketReadRecord mocks base method.
func (m *MockGfSpClientAPI) ListBucketReadRecord(ctx context.Context, bucket *types3.BucketInfo, startTimestampUs, endTimestampUs, maxRecordNum int64, opts ...grpc.DialOption) ([]*types.ReadRecord, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketReadRecord", varargs...)
	ret0, _ := ret[0].([]*types.ReadRecord)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListBucketReadRecord indicates an expected call of ListBucketReadRecord.
func (mr *MockGfSpClientAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketReadRecord", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListBucketReadRecord), varargs...)
}

// ListBucketsByIDs mocks base method.
func (m *MockGfSpClientAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketIDs, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCompleteMigrationBucketEvents mocks base method.
func (m *MockGfSpClientAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, srcSpID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCompleteMigrationBucketEvents", varargs...)
	ret0, _ := ret[0].([]*types3.EventCompleteMigrationBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDeletedObjectsByBlockNumberRange mocks base method.
func (m *MockGfSpClientAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeletedObjectsByBlockNumberRange", varargs...)
	ret0, _ := ret[0].([]*types.Object)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListDeletedObjectsByBlockNumberRange indicates an expected call of ListDeletedObjectsByBlockNumberRange.
func (mr *MockGfSpClientAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeletedObjectsByBlockNumberRange", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListDeletedObjectsByBlockNumberRange), varargs...)
}

// ListExpiredBucketsBySp mocks base method.
func (m *MockGfSpClientAPI) ListExpiredBucketsBySp(ctx context.Context, createAt int64, primarySpID uint32, limit int64, opts ...grpc.DialOption) ([]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, createAt, primarySpID, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExpiredBucketsBySp", varargs...)
	ret0, _ := ret[0].([]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGlobalVirtualGroupsByBucket mocks base method.
func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGlobalVirtualGroupsByBucket", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGlobalVirtualGroupsBySecondarySP mocks base method.
func (m *MockGfSpClientAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGlobalVirtualGroupsBySecondarySP", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroupsByIDs mocks base method.
func (m *MockGfSpClientAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint64, opts ...grpc.DialOption) (map[uint64]*types.Group, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, groupIDs}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMigrateBucketEvents mocks base method.
func (m *MockGfSpClientAPI) ListMigrateBucketEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListMigrateBucketEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMigrateBucketEvents", varargs...)
	ret0, _ := ret[0].([]*types.ListMigrateBucketEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectPolicies mocks base method.
func (m *MockGfSpClientAPI) ListObjectPolicies(ctx context.Context, objectName, bucketName string, startAfter uint64, actionType int32, limit uint32, opts ...grpc.DialOption) ([]*types.Policy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectName, bucketName, startAfter, actionType, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectPolicies", varargs...)
	ret0, _ := ret[0].([]*types.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectPolicies indicates an expected call of ListObjectPolicies.
func (mr *MockGfSpClientAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectPolicies", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectPolicies), varargs...)
}

// ListObjectsByBucketName mocks base method.
func (m *MockGfSpClientAPI) ListObjectsByBucketName(ctx context.Context, bucketName, accountID string, maxKeys uint64, startAfter, continuationToken, delimiter, prefix string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Object, uint64, uint64, bool, string, string, string, string, []string, string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByBucketName", varargs...)
	ret0, _ := ret[0].([]*types.Object)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(bool)
	ret4, _ := ret[4].(string)
	ret5, _ := ret[5].(string)
	ret6, _ := ret[6].(string)
	ret7, _ := ret[7].(string)
	ret8, _ := ret[8].([]string)
	ret9, _ := ret[9].(string)
	ret10, _ := ret[10].(error)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6, ret7, ret8, ret9, ret10
}

// ListObjectsByBucketName indicates an expected call of ListObjectsByBucketName.
func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByBucketName", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsByBucketName), varargs...)
}

// ListObjectsByGVGAndBucketForGC mocks base method.
func (m *MockGfSpClientAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, bucketID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByGVGAndBucketForGC", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsByGVGAndBucketForGC indicates an expected call of ListObjectsByGVGAndBucketForGC.
func (mr *MockGfSpClientAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByGVGAndBucketForGC", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsByGVGAndBucketForGC), varargs...)
}

// ListObjectsByIDs mocks base method.
func (m *MockGfSpClientAPI) ListObjectsByIDs(ctx context.Context, objectIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Object, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectIDs, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectsInGVG mocks base method.
func (m *MockGfSpClientAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsInGVG", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectsInGVGAndBucket mocks base method.
func (m *MockGfSpClientAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, bucketID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsInGVGAndBucket", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsInGVGAndBucket indicates an expected call of ListObjectsInGVGAndBucket.
func (mr *MockGfSpClientAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVGAndBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).ListObjectsInGVGAndBucket), varargs...)
}

// ListPaymentAccountStreams mocks base method.
func (m *MockGfSpClientAPI) ListPaymentAccountStreams(ctx context.Context, paymentAccount string, opts ...grpc.DialOption) ([]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, paymentAccount}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPaymentAccountStreams", varargs...)
	ret0, _ := ret[0].([]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSpExitEvents mocks base method.
func (m *MockGfSpClientAPI) ListSpExitEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) (*types.ListSpExitEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSpExitEvents", varargs...)
	ret0, _ := ret[0].(*types.ListSpExitEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSwapOutEvents mocks base method.
func (m *MockGfSpClientAPI) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSwapOutEvents", varargs...)
	ret0, _ := ret[0].([]*types.ListSwapOutEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserPaymentAccounts mocks base method.
func (m *MockGfSpClientAPI) ListUserPaymentAccounts(ctx context.Context, accountID string, opts ...grpc.DialOption) ([]*types.PaymentAccountMeta, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserPaymentAccounts", varargs...)
	ret0, _ := ret[0].([]*types.PaymentAccountMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVirtualGroupFamiliesSpID mocks base method.
func (m *MockGfSpClientAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroupFamily, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVirtualGroupFamiliesSpID", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// NotifyMigrateSwapOut mocks base method.
func (m *MockGfSpClientAPI) NotifyMigrateSwapOut(ctx context.Context, swapOut *types4.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 *MockGfSpClientAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut)
}

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

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

// NotifyPreMigrateBucketAndDeductQuota mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID)
}

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

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

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

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

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

// PostMigrateBucket indicates an expected call of PostMigrateBucket.
func (mr *MockGfSpClientAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).PostMigrateBucket), ctx, srcSPEndpoint, postMsg)
}

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

// PreMigrateBucket indicates an expected call of PreMigrateBucket.
func (mr *MockGfSpClientAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).PreMigrateBucket), ctx, srcSPEndpoint, preMsg)
}

// PrimarySpIncomeDetails mocks base method.
func (m *MockGfSpClientAPI) PrimarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.PrimarySpIncomeDetail, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PrimarySpIncomeDetails", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].([]*types.PrimarySpIncomeDetail)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// QueryBucketMigrate mocks base method.
func (m *MockGfSpClientAPI) QueryBucketMigrate(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryBucketMigrate", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// QueryLatestBucketQuota indicates an expected call of QueryLatestBucketQuota.
func (mr *MockGfSpClientAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLatestBucketQuota", reflect.TypeOf((*MockGfSpClientAPI)(nil).QueryLatestBucketQuota), ctx, endpoint, queryMsg)
}

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

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

// QuerySPExit mocks base method.
func (m *MockGfSpClientAPI) QuerySPExit(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QuerySPExit", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QuerySPHasEnoughQuotaForMigrateBucket mocks base method.
func (m *MockGfSpClientAPI) QuerySPHasEnoughQuotaForMigrateBucket(ctx context.Context, srcSPEndpoint string, queryMsg *gfsptask.GfSpBucketMigrationInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySPHasEnoughQuotaForMigrateBucket", ctx, srcSPEndpoint, queryMsg)
	ret0, _ := ret[0].(error)
	return ret0
}

// QuerySPHasEnoughQuotaForMigrateBucket indicates an expected call of QuerySPHasEnoughQuotaForMigrateBucket.
func (mr *MockGfSpClientAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPHasEnoughQuotaForMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).QuerySPHasEnoughQuotaForMigrateBucket), ctx, srcSPEndpoint, queryMsg)
}

// QueryTasks mocks base method.
func (m *MockGfSpClientAPI) QueryTasks(ctx context.Context, endpoint, subKey string, opts ...grpc.DialOption) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint, subKey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTasks", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecoupQuota mocks base method.
func (m *MockGfSpClientAPI) RecoupQuota(ctx context.Context, bucketID, extraQuota uint64, yearMonth string, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, extraQuota, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RecoupQuota", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// RejectMigrateBucket mocks base method.
func (m *MockGfSpClientAPI) RejectMigrateBucket(ctx context.Context, rejectMigrateBucket *types3.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 *MockGfSpClientAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket)
}

// RejectUnSealObject mocks base method.
func (m *MockGfSpClientAPI) RejectUnSealObject(ctx context.Context, object *types3.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 *MockGfSpClientAPIMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).RejectUnSealObject), ctx, object)
}

// ReplicatePiece mocks base method.
func (m *MockGfSpClientAPI) ReplicatePiece(ctx context.Context, task task.ReceivePieceTask, data []byte, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, data}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplicatePiece", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

// ReplicatePieceToSecondary indicates an expected call of ReplicatePieceToSecondary.
func (mr *MockGfSpClientAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePieceToSecondary", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReplicatePieceToSecondary), ctx, endpoint, receive, data)
}

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

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

// ReserveSwapIn mocks base method.
func (m *MockGfSpClientAPI) ReserveSwapIn(ctx context.Context, reserveSwapIn *types4.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 *MockGfSpClientAPIMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockGfSpClientAPI)(nil).ReserveSwapIn), ctx, reserveSwapIn)
}

// ResumableUploadObject mocks base method.
func (m *MockGfSpClientAPI) ResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, stream}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumableUploadObject", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SPExit mocks base method.
func (m *MockGfSpClientAPI) SPExit(ctx context.Context, spExit *types4.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 *MockGfSpClientAPIMockRecorder) SPExit(ctx, spExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockGfSpClientAPI)(nil).SPExit), ctx, spExit)
}

// SealObject mocks base method.
func (m *MockGfSpClientAPI) SealObject(ctx context.Context, object *types3.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 *MockGfSpClientAPIMockRecorder) SealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockGfSpClientAPI)(nil).SealObject), ctx, object)
}

// SealObjectV2 mocks base method.
func (m *MockGfSpClientAPI) SealObjectV2(ctx context.Context, object *types3.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 *MockGfSpClientAPIMockRecorder) SealObjectV2(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObjectV2", reflect.TypeOf((*MockGfSpClientAPI)(nil).SealObjectV2), ctx, object)
}

// SecondarySpIncomeDetails mocks base method.
func (m *MockGfSpClientAPI) SecondarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.SecondarySpIncomeDetail, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SecondarySpIncomeDetails", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].([]*types.SecondarySpIncomeDetail)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SignBucketMigrationInfo mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignBucketMigrationInfo), ctx, task)
}

// SignCreateBucketApproval mocks base method.
func (m *MockGfSpClientAPI) SignCreateBucketApproval(ctx context.Context, bucket *types3.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 *MockGfSpClientAPIMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignCreateBucketApproval), ctx, bucket)
}

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

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

// SignMigrateBucketApproval mocks base method.
func (m *MockGfSpClientAPI) SignMigrateBucketApproval(ctx context.Context, bucket *types3.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 *MockGfSpClientAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignMigrateBucketApproval), ctx, bucket)
}

// SignMigrateGVG mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignMigrateGVG), ctx, task)
}

// SignP2PPingMsg mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignP2PPingMsg), ctx, ping)
}

// SignP2PPongMsg mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignP2PPongMsg), ctx, pong)
}

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

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

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

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

// SignReplicatePieceApproval mocks base method.
func (m *MockGfSpClientAPI) 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 *MockGfSpClientAPIMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignReplicatePieceApproval), ctx, task)
}

// SignSecondarySPMigrationBucket mocks base method.
func (m *MockGfSpClientAPI) SignSecondarySPMigrationBucket(ctx context.Context, signDoc *types3.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 *MockGfSpClientAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignSecondarySPMigrationBucket), ctx, signDoc)
}

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

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

// SignSwapOut mocks base method.
func (m *MockGfSpClientAPI) SignSwapOut(ctx context.Context, swapOut *types4.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 *MockGfSpClientAPIMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).SignSwapOut), ctx, swapOut)
}

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

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

// SwapOut mocks base method.
func (m *MockGfSpClientAPI) SwapOut(ctx context.Context, swapOut *types4.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 *MockGfSpClientAPIMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockGfSpClientAPI)(nil).SwapOut), ctx, swapOut)
}

// UpdateSPPrice mocks base method.
func (m *MockGfSpClientAPI) UpdateSPPrice(ctx context.Context, price *types2.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 *MockGfSpClientAPIMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockGfSpClientAPI)(nil).UpdateSPPrice), ctx, price)
}

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

// UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey.
func (mr *MockGfSpClientAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockGfSpClientAPI)(nil).UpdateUserPublicKey), varargs...)
}

// UpdateUserPublicKeyV2 mocks base method.
func (m *MockGfSpClientAPI) UpdateUserPublicKeyV2(ctx context.Context, account, domain, userPublicKey string, expiryDate int64, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey, expiryDate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserPublicKeyV2", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserPublicKeyV2 indicates an expected call of UpdateUserPublicKeyV2.
func (mr *MockGfSpClientAPIMockRecorder) UpdateUserPublicKeyV2(ctx, account, domain, userPublicKey, expiryDate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, userPublicKey, expiryDate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKeyV2", reflect.TypeOf((*MockGfSpClientAPI)(nil).UpdateUserPublicKeyV2), varargs...)
}

// UploadObject mocks base method.
func (m *MockGfSpClientAPI) UploadObject(ctx context.Context, task task.UploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, stream}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadObject", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// VerifyAuthentication mocks base method.
func (m *MockGfSpClientAPI) VerifyAuthentication(ctx context.Context, auth module.AuthOpType, account, bucket, object string, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, auth, account, bucket, object}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyAuthentication", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyAuthentication indicates an expected call of VerifyAuthentication.
func (mr *MockGfSpClientAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, auth, account, bucket, object}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyAuthentication), varargs...)
}

// VerifyGNFD1EddsaSignature mocks base method.
func (m *MockGfSpClientAPI) VerifyGNFD1EddsaSignature(ctx context.Context, account, domain, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, offChainSig, realMsgToSign}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyGNFD1EddsaSignature", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature.
func (mr *MockGfSpClientAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, offChainSig, realMsgToSign}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyGNFD1EddsaSignature), varargs...)
}

// VerifyGNFD2EddsaSignature mocks base method.
func (m *MockGfSpClientAPI) VerifyGNFD2EddsaSignature(ctx context.Context, account, domain, userPublicKey, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey, offChainSig, realMsgToSign}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyGNFD2EddsaSignature", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD2EddsaSignature indicates an expected call of VerifyGNFD2EddsaSignature.
func (mr *MockGfSpClientAPIMockRecorder) VerifyGNFD2EddsaSignature(ctx, account, domain, userPublicKey, offChainSig, realMsgToSign any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, userPublicKey, offChainSig, realMsgToSign}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD2EddsaSignature", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyGNFD2EddsaSignature), varargs...)
}

// VerifyMigrateGVGPermission mocks base method.
func (m *MockGfSpClientAPI) VerifyMigrateGVGPermission(ctx context.Context, bucketID uint64, gvgID, dstSpID uint32, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, gvgID, dstSpID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyMigrateGVGPermission", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// VerifyPermission mocks base method.
func (m *MockGfSpClientAPI) VerifyPermission(ctx context.Context, Operator, bucketName, objectName string, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, Operator, bucketName, objectName, actionType}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyPermission", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyPermission indicates an expected call of VerifyPermission.
func (mr *MockGfSpClientAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, Operator, bucketName, objectName, actionType}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermission", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyPermission), varargs...)
}

// VerifyPermissionByID mocks base method.
func (m *MockGfSpClientAPI) VerifyPermissionByID(ctx context.Context, Operator string, resourceType resource.ResourceType, resourceID uint64, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, Operator, resourceType, resourceID, actionType}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyPermissionByID", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyPermissionByID indicates an expected call of VerifyPermissionByID.
func (mr *MockGfSpClientAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, Operator, resourceType, resourceID, actionType}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermissionByID", reflect.TypeOf((*MockGfSpClientAPI)(nil).VerifyPermissionByID), varargs...)
}

// MockApproverAPI is a mock of ApproverAPI interface.
type MockApproverAPI struct {
	ctrl     *gomock.Controller
	recorder *MockApproverAPIMockRecorder
}

// MockApproverAPIMockRecorder is the mock recorder for MockApproverAPI.
type MockApproverAPIMockRecorder struct {
	mock *MockApproverAPI
}

// NewMockApproverAPI creates a new mock instance.
func NewMockApproverAPI(ctrl *gomock.Controller) *MockApproverAPI {
	mock := &MockApproverAPI{ctrl: ctrl}
	mock.recorder = &MockApproverAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockAuthenticatorAPI is a mock of AuthenticatorAPI interface.
type MockAuthenticatorAPI struct {
	ctrl     *gomock.Controller
	recorder *MockAuthenticatorAPIMockRecorder
}

// MockAuthenticatorAPIMockRecorder is the mock recorder for MockAuthenticatorAPI.
type MockAuthenticatorAPIMockRecorder struct {
	mock *MockAuthenticatorAPI
}

// NewMockAuthenticatorAPI creates a new mock instance.
func NewMockAuthenticatorAPI(ctrl *gomock.Controller) *MockAuthenticatorAPI {
	mock := &MockAuthenticatorAPI{ctrl: ctrl}
	mock.recorder = &MockAuthenticatorAPIMockRecorder{mock}
	return mock
}

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

// DeleteAuthKeysV2 mocks base method.
func (m *MockAuthenticatorAPI) DeleteAuthKeysV2(ctx context.Context, account, domain string, userPublicKeys []string, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKeys}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAuthKeysV2", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAuthKeyV2 mocks base method.
func (m *MockAuthenticatorAPI) GetAuthKeyV2(ctx context.Context, account, domain, userPublicKey string, opts ...grpc.DialOption) (string, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuthKeyV2", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetAuthNonce mocks base method.
func (m *MockAuthenticatorAPI) GetAuthNonce(ctx context.Context, account, domain string, opts ...grpc.DialOption) (int32, int32, string, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuthNonce", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(int32)
	ret2, _ := ret[2].(string)
	ret3, _ := ret[3].(int64)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// ListAuthKeysV2 mocks base method.
func (m *MockAuthenticatorAPI) ListAuthKeysV2(ctx context.Context, account, domain string, opts ...grpc.DialOption) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAuthKeysV2", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// UpdateUserPublicKey indicates an expected call of UpdateUserPublicKey.
func (mr *MockAuthenticatorAPIMockRecorder) UpdateUserPublicKey(ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, currentNonce, nonce, userPublicKey, expiryDate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKey", reflect.TypeOf((*MockAuthenticatorAPI)(nil).UpdateUserPublicKey), varargs...)
}

// UpdateUserPublicKeyV2 mocks base method.
func (m *MockAuthenticatorAPI) UpdateUserPublicKeyV2(ctx context.Context, account, domain, userPublicKey string, expiryDate int64, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey, expiryDate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserPublicKeyV2", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserPublicKeyV2 indicates an expected call of UpdateUserPublicKeyV2.
func (mr *MockAuthenticatorAPIMockRecorder) UpdateUserPublicKeyV2(ctx, account, domain, userPublicKey, expiryDate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, userPublicKey, expiryDate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPublicKeyV2", reflect.TypeOf((*MockAuthenticatorAPI)(nil).UpdateUserPublicKeyV2), varargs...)
}

// VerifyAuthentication mocks base method.
func (m *MockAuthenticatorAPI) VerifyAuthentication(ctx context.Context, auth module.AuthOpType, account, bucket, object string, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, auth, account, bucket, object}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyAuthentication", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyAuthentication indicates an expected call of VerifyAuthentication.
func (mr *MockAuthenticatorAPIMockRecorder) VerifyAuthentication(ctx, auth, account, bucket, object any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, auth, account, bucket, object}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAuthentication", reflect.TypeOf((*MockAuthenticatorAPI)(nil).VerifyAuthentication), varargs...)
}

// VerifyGNFD1EddsaSignature mocks base method.
func (m *MockAuthenticatorAPI) VerifyGNFD1EddsaSignature(ctx context.Context, account, domain, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, offChainSig, realMsgToSign}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyGNFD1EddsaSignature", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD1EddsaSignature indicates an expected call of VerifyGNFD1EddsaSignature.
func (mr *MockAuthenticatorAPIMockRecorder) VerifyGNFD1EddsaSignature(ctx, account, domain, offChainSig, realMsgToSign any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, offChainSig, realMsgToSign}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD1EddsaSignature", reflect.TypeOf((*MockAuthenticatorAPI)(nil).VerifyGNFD1EddsaSignature), varargs...)
}

// VerifyGNFD2EddsaSignature mocks base method.
func (m *MockAuthenticatorAPI) VerifyGNFD2EddsaSignature(ctx context.Context, account, domain, userPublicKey, offChainSig string, realMsgToSign []byte, opts ...grpc.DialOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, domain, userPublicKey, offChainSig, realMsgToSign}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyGNFD2EddsaSignature", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyGNFD2EddsaSignature indicates an expected call of VerifyGNFD2EddsaSignature.
func (mr *MockAuthenticatorAPIMockRecorder) VerifyGNFD2EddsaSignature(ctx, account, domain, userPublicKey, offChainSig, realMsgToSign any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, account, domain, userPublicKey, offChainSig, realMsgToSign}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyGNFD2EddsaSignature", reflect.TypeOf((*MockAuthenticatorAPI)(nil).VerifyGNFD2EddsaSignature), varargs...)
}

// MockDownloaderAPI is a mock of DownloaderAPI interface.
type MockDownloaderAPI struct {
	ctrl     *gomock.Controller
	recorder *MockDownloaderAPIMockRecorder
}

// MockDownloaderAPIMockRecorder is the mock recorder for MockDownloaderAPI.
type MockDownloaderAPIMockRecorder struct {
	mock *MockDownloaderAPI
}

// NewMockDownloaderAPI creates a new mock instance.
func NewMockDownloaderAPI(ctrl *gomock.Controller) *MockDownloaderAPI {
	mock := &MockDownloaderAPI{ctrl: ctrl}
	mock.recorder = &MockDownloaderAPIMockRecorder{mock}
	return mock
}

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

// DeductQuotaForBucketMigrate mocks base method.
func (m *MockDownloaderAPI) DeductQuotaForBucketMigrate(ctx context.Context, bucketID, deductQuota uint64, yearMonth string, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, deductQuota, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeductQuotaForBucketMigrate", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetChallengeInfo mocks base method.
func (m *MockDownloaderAPI) GetChallengeInfo(ctx context.Context, challengePieceTask task.ChallengePieceTask, opts ...grpc.DialOption) ([]byte, [][]byte, []byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, challengePieceTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChallengeInfo", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([][]byte)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// GetObject mocks base method.
func (m *MockDownloaderAPI) GetObject(ctx context.Context, downloadObjectTask task.DownloadObjectTask, opts ...grpc.DialOption) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, downloadObjectTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObject", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPiece mocks base method.
func (m *MockDownloaderAPI) GetPiece(ctx context.Context, downloadPieceTask task.DownloadPieceTask, opts ...grpc.DialOption) ([]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, downloadPieceTask}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPiece", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecoupQuota mocks base method.
func (m *MockDownloaderAPI) RecoupQuota(ctx context.Context, bucketID, extraQuota uint64, yearMonth string, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, extraQuota, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RecoupQuota", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockGaterAPI is a mock of GaterAPI interface.
type MockGaterAPI struct {
	ctrl     *gomock.Controller
	recorder *MockGaterAPIMockRecorder
}

// MockGaterAPIMockRecorder is the mock recorder for MockGaterAPI.
type MockGaterAPIMockRecorder struct {
	mock *MockGaterAPI
}

// NewMockGaterAPI creates a new mock instance.
func NewMockGaterAPI(ctrl *gomock.Controller) *MockGaterAPI {
	mock := &MockGaterAPI{ctrl: ctrl}
	mock.recorder = &MockGaterAPIMockRecorder{mock}
	return mock
}

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

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

// DoneReplicatePieceToSecondary indicates an expected call of DoneReplicatePieceToSecondary.
func (mr *MockGaterAPIMockRecorder) DoneReplicatePieceToSecondary(ctx, endpoint, receive any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoneReplicatePieceToSecondary", reflect.TypeOf((*MockGaterAPI)(nil).DoneReplicatePieceToSecondary), ctx, endpoint, receive)
}

// GetPieceFromECChunks mocks base method.
func (m *MockGaterAPI) GetPieceFromECChunks(ctx context.Context, endpoint string, task task.RecoveryPieceTask) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPieceFromECChunks", ctx, endpoint, task)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// GetSwapOutApproval indicates an expected call of GetSwapOutApproval.
func (mr *MockGaterAPIMockRecorder) GetSwapOutApproval(ctx, destSPEndpoint, swapOutApproval any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSwapOutApproval", reflect.TypeOf((*MockGaterAPI)(nil).GetSwapOutApproval), ctx, destSPEndpoint, swapOutApproval)
}

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

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

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

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

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

// PostMigrateBucket indicates an expected call of PostMigrateBucket.
func (mr *MockGaterAPIMockRecorder) PostMigrateBucket(ctx, srcSPEndpoint, postMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).PostMigrateBucket), ctx, srcSPEndpoint, postMsg)
}

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

// PreMigrateBucket indicates an expected call of PreMigrateBucket.
func (mr *MockGaterAPIMockRecorder) PreMigrateBucket(ctx, srcSPEndpoint, preMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).PreMigrateBucket), ctx, srcSPEndpoint, preMsg)
}

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

// QueryLatestBucketQuota indicates an expected call of QueryLatestBucketQuota.
func (mr *MockGaterAPIMockRecorder) QueryLatestBucketQuota(ctx, endpoint, queryMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryLatestBucketQuota", reflect.TypeOf((*MockGaterAPI)(nil).QueryLatestBucketQuota), ctx, endpoint, queryMsg)
}

// QuerySPHasEnoughQuotaForMigrateBucket mocks base method.
func (m *MockGaterAPI) QuerySPHasEnoughQuotaForMigrateBucket(ctx context.Context, srcSPEndpoint string, queryMsg *gfsptask.GfSpBucketMigrationInfo) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QuerySPHasEnoughQuotaForMigrateBucket", ctx, srcSPEndpoint, queryMsg)
	ret0, _ := ret[0].(error)
	return ret0
}

// QuerySPHasEnoughQuotaForMigrateBucket indicates an expected call of QuerySPHasEnoughQuotaForMigrateBucket.
func (mr *MockGaterAPIMockRecorder) QuerySPHasEnoughQuotaForMigrateBucket(ctx, srcSPEndpoint, queryMsg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerySPHasEnoughQuotaForMigrateBucket", reflect.TypeOf((*MockGaterAPI)(nil).QuerySPHasEnoughQuotaForMigrateBucket), ctx, srcSPEndpoint, queryMsg)
}

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

// ReplicatePieceToSecondary indicates an expected call of ReplicatePieceToSecondary.
func (mr *MockGaterAPIMockRecorder) ReplicatePieceToSecondary(ctx, endpoint, receive, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicatePieceToSecondary", reflect.TypeOf((*MockGaterAPI)(nil).ReplicatePieceToSecondary), ctx, endpoint, receive, data)
}

// MockManagerAPI is a mock of ManagerAPI interface.
type MockManagerAPI struct {
	ctrl     *gomock.Controller
	recorder *MockManagerAPIMockRecorder
}

// MockManagerAPIMockRecorder is the mock recorder for MockManagerAPI.
type MockManagerAPIMockRecorder struct {
	mock *MockManagerAPI
}

// NewMockManagerAPI creates a new mock instance.
func NewMockManagerAPI(ctrl *gomock.Controller) *MockManagerAPI {
	mock := &MockManagerAPI{ctrl: ctrl}
	mock.recorder = &MockManagerAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// NotifyMigrateSwapOut mocks base method.
func (m *MockManagerAPI) NotifyMigrateSwapOut(ctx context.Context, swapOut *types4.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 *MockManagerAPIMockRecorder) NotifyMigrateSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyMigrateSwapOut", reflect.TypeOf((*MockManagerAPI)(nil).NotifyMigrateSwapOut), ctx, swapOut)
}

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

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

// NotifyPreMigrateBucketAndDeductQuota mocks base method.
func (m *MockManagerAPI) 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 *MockManagerAPIMockRecorder) NotifyPreMigrateBucketAndDeductQuota(ctx, bucketID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPreMigrateBucketAndDeductQuota", reflect.TypeOf((*MockManagerAPI)(nil).NotifyPreMigrateBucketAndDeductQuota), ctx, bucketID)
}

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

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

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

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

// MockMetadataAPI is a mock of MetadataAPI interface.
type MockMetadataAPI struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataAPIMockRecorder
}

// MockMetadataAPIMockRecorder is the mock recorder for MockMetadataAPI.
type MockMetadataAPIMockRecorder struct {
	mock *MockMetadataAPI
}

// NewMockMetadataAPI creates a new mock instance.
func NewMockMetadataAPI(ctrl *gomock.Controller) *MockMetadataAPI {
	mock := &MockMetadataAPI{ctrl: ctrl}
	mock.recorder = &MockMetadataAPIMockRecorder{mock}
	return mock
}

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

// GetBsDBInfo mocks base method.
func (m *MockMetadataAPI) GetBsDBInfo(ctx context.Context, blockHeight uint64, opts ...grpc.DialOption) (*types.GfSpGetBsDBInfoResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockHeight}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBsDBInfo", varargs...)
	ret0, _ := ret[0].(*types.GfSpGetBsDBInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketByBucketID mocks base method.
func (m *MockMetadataAPI) GetBucketByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketByBucketID", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketByBucketName mocks base method.
func (m *MockMetadataAPI) GetBucketByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketByBucketName", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketInfoByBucketName mocks base method.
func (m *MockMetadataAPI) GetBucketInfoByBucketName(ctx context.Context, bucketName string, opts ...grpc.DialOption) (*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketInfoByBucketName", varargs...)
	ret0, _ := ret[0].(*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBucketMeta mocks base method.
func (m *MockMetadataAPI) GetBucketMeta(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.VGFInfoBucket, *types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketMeta", varargs...)
	ret0, _ := ret[0].(*types.VGFInfoBucket)
	ret1, _ := ret[1].(*types0.StreamRecord)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetBucketReadQuota mocks base method.
func (m *MockMetadataAPI) GetBucketReadQuota(ctx context.Context, bucket *types3.BucketInfo, yearMonth string, opts ...grpc.DialOption) (uint64, uint64, uint64, uint64, uint64, uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucket, yearMonth}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketReadQuota", varargs...)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(uint64)
	ret4, _ := ret[4].(uint64)
	ret5, _ := ret[5].(uint64)
	ret6, _ := ret[6].(error)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6
}

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

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

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

// GetBucketSize mocks base method.
func (m *MockMetadataAPI) GetBucketSize(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBucketSize", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEndpointBySpID mocks base method.
func (m *MockMetadataAPI) GetEndpointBySpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEndpointBySpID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGlobalVirtualGroup mocks base method.
func (m *MockMetadataAPI) GetGlobalVirtualGroup(ctx context.Context, bucketID uint64, lvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, lvgID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalVirtualGroup", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGlobalVirtualGroupByGvgID mocks base method.
func (m *MockMetadataAPI) GetGlobalVirtualGroupByGvgID(ctx context.Context, gvgID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalVirtualGroupByGvgID", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupList mocks base method.
func (m *MockMetadataAPI) GetGroupList(ctx context.Context, name, prefix, sourceType string, limit, offset int64, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Group, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupList", varargs...)
	ret0, _ := ret[0].([]*types.Group)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGroupList indicates an expected call of GetGroupList.
func (mr *MockMetadataAPIMockRecorder) GetGroupList(ctx, name, prefix, sourceType, limit, offset, includeRemoved any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, name, prefix, sourceType, limit, offset, includeRemoved}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupList", reflect.TypeOf((*MockMetadataAPI)(nil).GetGroupList), varargs...)
}

// GetGroupMembers mocks base method.
func (m *MockMetadataAPI) GetGroupMembers(ctx context.Context, groupID uint64, startAfter string, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, groupID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGroupMembers", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestBucketReadQuota mocks base method.
func (m *MockMetadataAPI) GetLatestBucketReadQuota(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) (*gfsptask.GfSpBucketQuotaInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLatestBucketReadQuota", varargs...)
	ret0, _ := ret[0].(*gfsptask.GfSpBucketQuotaInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetObjectByID mocks base method.
func (m *MockMetadataAPI) GetObjectByID(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (*types3.ObjectInfo, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectByID", varargs...)
	ret0, _ := ret[0].(*types3.ObjectInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetObjectMeta mocks base method.
func (m *MockMetadataAPI) GetObjectMeta(ctx context.Context, objectName, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types.Object, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectName, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetObjectMeta", varargs...)
	ret0, _ := ret[0].(*types.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPaymentByBucketID mocks base method.
func (m *MockMetadataAPI) GetPaymentByBucketID(ctx context.Context, bucketID int64, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPaymentByBucketID", varargs...)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPaymentByBucketName mocks base method.
func (m *MockMetadataAPI) GetPaymentByBucketName(ctx context.Context, bucketName string, includePrivate bool, opts ...grpc.DialOption) (*types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPaymentByBucketName", varargs...)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSPInfo mocks base method.
func (m *MockMetadataAPI) GetSPInfo(ctx context.Context, operatorAddress string, opts ...grpc.DialOption) (*types2.StorageProvider, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, operatorAddress}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSPInfo", varargs...)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSPMigratingBucketNumber mocks base method.
func (m *MockMetadataAPI) GetSPMigratingBucketNumber(ctx context.Context, spID uint32, opts ...grpc.DialOption) (uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSPMigratingBucketNumber", varargs...)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStatus mocks base method.
func (m *MockMetadataAPI) GetStatus(ctx context.Context, opts ...grpc.DialOption) (*types.Status, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetStatus", varargs...)
	ret0, _ := ret[0].(*types.Status)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUploadObjectSegment mocks base method.
func (m *MockMetadataAPI) GetUploadObjectSegment(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (uint32, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUploadObjectSegment", varargs...)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUploadObjectState mocks base method.
func (m *MockMetadataAPI) GetUploadObjectState(ctx context.Context, objectID uint64, opts ...grpc.DialOption) (int32, string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUploadObjectState", varargs...)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetUserBuckets mocks base method.
func (m *MockMetadataAPI) GetUserBuckets(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.VGFInfoBucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserBuckets", varargs...)
	ret0, _ := ret[0].([]*types.VGFInfoBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserBucketsCount mocks base method.
func (m *MockMetadataAPI) GetUserBucketsCount(ctx context.Context, account string, includeRemoved bool, opts ...grpc.DialOption) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, account, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserBucketsCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserGroups mocks base method.
func (m *MockMetadataAPI) GetUserGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserGroups", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserOwnedGroups mocks base method.
func (m *MockMetadataAPI) GetUserOwnedGroups(ctx context.Context, accountID string, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.GroupMember, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserOwnedGroups", varargs...)
	ret0, _ := ret[0].([]*types.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVirtualGroupFamily mocks base method.
func (m *MockMetadataAPI) GetVirtualGroupFamily(ctx context.Context, vgfID uint32, opts ...grpc.DialOption) (*types4.GlobalVirtualGroupFamily, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, vgfID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVirtualGroupFamily", varargs...)
	ret0, _ := ret[0].(*types4.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBucketReadQuota mocks base method.
func (m *MockMetadataAPI) ListBucketReadQuota(ctx context.Context, yearMonth string, offset, limit uint32, opts ...grpc.DialOption) ([]*types.BucketReadQuotaRecord, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, yearMonth, offset, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketReadQuota", varargs...)
	ret0, _ := ret[0].([]*types.BucketReadQuotaRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBucketReadRecord mocks base method.
func (m *MockMetadataAPI) ListBucketReadRecord(ctx context.Context, bucket *types3.BucketInfo, startTimestampUs, endTimestampUs, maxRecordNum int64, opts ...grpc.DialOption) ([]*types.ReadRecord, int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketReadRecord", varargs...)
	ret0, _ := ret[0].([]*types.ReadRecord)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListBucketReadRecord indicates an expected call of ListBucketReadRecord.
func (mr *MockMetadataAPIMockRecorder) ListBucketReadRecord(ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, bucket, startTimestampUs, endTimestampUs, maxRecordNum}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketReadRecord", reflect.TypeOf((*MockMetadataAPI)(nil).ListBucketReadRecord), varargs...)
}

// ListBucketsByIDs mocks base method.
func (m *MockMetadataAPI) ListBucketsByIDs(ctx context.Context, bucketIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketIDs, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBucketsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCompleteMigrationBucketEvents mocks base method.
func (m *MockMetadataAPI) ListCompleteMigrationBucketEvents(ctx context.Context, blockID uint64, srcSpID uint32, opts ...grpc.DialOption) ([]*types3.EventCompleteMigrationBucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, srcSpID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCompleteMigrationBucketEvents", varargs...)
	ret0, _ := ret[0].([]*types3.EventCompleteMigrationBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDeletedObjectsByBlockNumberRange mocks base method.
func (m *MockMetadataAPI) ListDeletedObjectsByBlockNumberRange(ctx context.Context, spOperatorAddress string, startBlockNumber, endBlockNumber uint64, includePrivate bool, opts ...grpc.DialOption) ([]*types.Object, uint64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeletedObjectsByBlockNumberRange", varargs...)
	ret0, _ := ret[0].([]*types.Object)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListDeletedObjectsByBlockNumberRange indicates an expected call of ListDeletedObjectsByBlockNumberRange.
func (mr *MockMetadataAPIMockRecorder) ListDeletedObjectsByBlockNumberRange(ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, spOperatorAddress, startBlockNumber, endBlockNumber, includePrivate}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeletedObjectsByBlockNumberRange", reflect.TypeOf((*MockMetadataAPI)(nil).ListDeletedObjectsByBlockNumberRange), varargs...)
}

// ListExpiredBucketsBySp mocks base method.
func (m *MockMetadataAPI) ListExpiredBucketsBySp(ctx context.Context, createAt int64, primarySpID uint32, limit int64, opts ...grpc.DialOption) ([]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, createAt, primarySpID, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExpiredBucketsBySp", varargs...)
	ret0, _ := ret[0].([]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGlobalVirtualGroupsByBucket mocks base method.
func (m *MockMetadataAPI) ListGlobalVirtualGroupsByBucket(ctx context.Context, bucketID uint64, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGlobalVirtualGroupsByBucket", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGlobalVirtualGroupsBySecondarySP mocks base method.
func (m *MockMetadataAPI) ListGlobalVirtualGroupsBySecondarySP(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGlobalVirtualGroupsBySecondarySP", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListGroupsByIDs mocks base method.
func (m *MockMetadataAPI) ListGroupsByIDs(ctx context.Context, groupIDs []uint64, opts ...grpc.DialOption) (map[uint64]*types.Group, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, groupIDs}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGroupsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMigrateBucketEvents mocks base method.
func (m *MockMetadataAPI) ListMigrateBucketEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListMigrateBucketEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMigrateBucketEvents", varargs...)
	ret0, _ := ret[0].([]*types.ListMigrateBucketEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectPolicies mocks base method.
func (m *MockMetadataAPI) ListObjectPolicies(ctx context.Context, objectName, bucketName string, startAfter uint64, actionType int32, limit uint32, opts ...grpc.DialOption) ([]*types.Policy, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectName, bucketName, startAfter, actionType, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectPolicies", varargs...)
	ret0, _ := ret[0].([]*types.Policy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectPolicies indicates an expected call of ListObjectPolicies.
func (mr *MockMetadataAPIMockRecorder) ListObjectPolicies(ctx, objectName, bucketName, startAfter, actionType, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, objectName, bucketName, startAfter, actionType, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectPolicies", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectPolicies), varargs...)
}

// ListObjectsByBucketName mocks base method.
func (m *MockMetadataAPI) ListObjectsByBucketName(ctx context.Context, bucketName, accountID string, maxKeys uint64, startAfter, continuationToken, delimiter, prefix string, includeRemoved bool, opts ...grpc.DialOption) ([]*types.Object, uint64, uint64, bool, string, string, string, string, []string, string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByBucketName", varargs...)
	ret0, _ := ret[0].([]*types.Object)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(uint64)
	ret3, _ := ret[3].(bool)
	ret4, _ := ret[4].(string)
	ret5, _ := ret[5].(string)
	ret6, _ := ret[6].(string)
	ret7, _ := ret[7].(string)
	ret8, _ := ret[8].([]string)
	ret9, _ := ret[9].(string)
	ret10, _ := ret[10].(error)
	return ret0, ret1, ret2, ret3, ret4, ret5, ret6, ret7, ret8, ret9, ret10
}

// ListObjectsByBucketName indicates an expected call of ListObjectsByBucketName.
func (mr *MockMetadataAPIMockRecorder) ListObjectsByBucketName(ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, bucketName, accountID, maxKeys, startAfter, continuationToken, delimiter, prefix, includeRemoved}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByBucketName", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsByBucketName), varargs...)
}

// ListObjectsByGVGAndBucketForGC mocks base method.
func (m *MockMetadataAPI) ListObjectsByGVGAndBucketForGC(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, bucketID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByGVGAndBucketForGC", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsByGVGAndBucketForGC indicates an expected call of ListObjectsByGVGAndBucketForGC.
func (mr *MockMetadataAPIMockRecorder) ListObjectsByGVGAndBucketForGC(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsByGVGAndBucketForGC", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsByGVGAndBucketForGC), varargs...)
}

// ListObjectsByIDs mocks base method.
func (m *MockMetadataAPI) ListObjectsByIDs(ctx context.Context, objectIDs []uint64, includeRemoved bool, opts ...grpc.DialOption) (map[uint64]*types.Object, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, objectIDs, includeRemoved}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsByIDs", varargs...)
	ret0, _ := ret[0].(map[uint64]*types.Object)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectsInGVG mocks base method.
func (m *MockMetadataAPI) ListObjectsInGVG(ctx context.Context, gvgID uint32, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsInGVG", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListObjectsInGVGAndBucket mocks base method.
func (m *MockMetadataAPI) ListObjectsInGVGAndBucket(ctx context.Context, gvgID uint32, bucketID, startAfter uint64, limit uint32, opts ...grpc.DialOption) ([]*types.ObjectDetails, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, gvgID, bucketID, startAfter, limit}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListObjectsInGVGAndBucket", varargs...)
	ret0, _ := ret[0].([]*types.ObjectDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListObjectsInGVGAndBucket indicates an expected call of ListObjectsInGVGAndBucket.
func (mr *MockMetadataAPIMockRecorder) ListObjectsInGVGAndBucket(ctx, gvgID, bucketID, startAfter, limit any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, gvgID, bucketID, startAfter, limit}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsInGVGAndBucket", reflect.TypeOf((*MockMetadataAPI)(nil).ListObjectsInGVGAndBucket), varargs...)
}

// ListPaymentAccountStreams mocks base method.
func (m *MockMetadataAPI) ListPaymentAccountStreams(ctx context.Context, paymentAccount string, opts ...grpc.DialOption) ([]*types.Bucket, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, paymentAccount}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPaymentAccountStreams", varargs...)
	ret0, _ := ret[0].([]*types.Bucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSpExitEvents mocks base method.
func (m *MockMetadataAPI) ListSpExitEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) (*types.ListSpExitEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSpExitEvents", varargs...)
	ret0, _ := ret[0].(*types.ListSpExitEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSwapOutEvents mocks base method.
func (m *MockMetadataAPI) ListSwapOutEvents(ctx context.Context, blockID uint64, spID uint32, opts ...grpc.DialOption) ([]*types.ListSwapOutEvents, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, blockID, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSwapOutEvents", varargs...)
	ret0, _ := ret[0].([]*types.ListSwapOutEvents)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserPaymentAccounts mocks base method.
func (m *MockMetadataAPI) ListUserPaymentAccounts(ctx context.Context, accountID string, opts ...grpc.DialOption) ([]*types.PaymentAccountMeta, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, accountID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUserPaymentAccounts", varargs...)
	ret0, _ := ret[0].([]*types.PaymentAccountMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVirtualGroupFamiliesSpID mocks base method.
func (m *MockMetadataAPI) ListVirtualGroupFamiliesSpID(ctx context.Context, spID uint32, opts ...grpc.DialOption) ([]*types4.GlobalVirtualGroupFamily, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListVirtualGroupFamiliesSpID", varargs...)
	ret0, _ := ret[0].([]*types4.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PrimarySpIncomeDetails mocks base method.
func (m *MockMetadataAPI) PrimarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.PrimarySpIncomeDetail, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PrimarySpIncomeDetails", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].([]*types.PrimarySpIncomeDetail)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// SecondarySpIncomeDetails mocks base method.
func (m *MockMetadataAPI) SecondarySpIncomeDetails(ctx context.Context, spID uint32, opts ...grpc.DialOption) (int64, []*types.SecondarySpIncomeDetail, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, spID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SecondarySpIncomeDetails", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].([]*types.SecondarySpIncomeDetail)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// VerifyMigrateGVGPermission mocks base method.
func (m *MockMetadataAPI) VerifyMigrateGVGPermission(ctx context.Context, bucketID uint64, gvgID, dstSpID uint32, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, bucketID, gvgID, dstSpID}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyMigrateGVGPermission", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// VerifyPermission mocks base method.
func (m *MockMetadataAPI) VerifyPermission(ctx context.Context, Operator, bucketName, objectName string, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, Operator, bucketName, objectName, actionType}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyPermission", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyPermission indicates an expected call of VerifyPermission.
func (mr *MockMetadataAPIMockRecorder) VerifyPermission(ctx, Operator, bucketName, objectName, actionType any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, Operator, bucketName, objectName, actionType}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermission", reflect.TypeOf((*MockMetadataAPI)(nil).VerifyPermission), varargs...)
}

// VerifyPermissionByID mocks base method.
func (m *MockMetadataAPI) VerifyPermissionByID(ctx context.Context, Operator string, resourceType resource.ResourceType, resourceID uint64, actionType types1.ActionType, opts ...grpc.DialOption) (*types1.Effect, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, Operator, resourceType, resourceID, actionType}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyPermissionByID", varargs...)
	ret0, _ := ret[0].(*types1.Effect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyPermissionByID indicates an expected call of VerifyPermissionByID.
func (mr *MockMetadataAPIMockRecorder) VerifyPermissionByID(ctx, Operator, resourceType, resourceID, actionType any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, Operator, resourceType, resourceID, actionType}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyPermissionByID", reflect.TypeOf((*MockMetadataAPI)(nil).VerifyPermissionByID), varargs...)
}

// MockP2PAPI is a mock of P2PAPI interface.
type MockP2PAPI struct {
	ctrl     *gomock.Controller
	recorder *MockP2PAPIMockRecorder
}

// MockP2PAPIMockRecorder is the mock recorder for MockP2PAPI.
type MockP2PAPIMockRecorder struct {
	mock *MockP2PAPI
}

// NewMockP2PAPI creates a new mock instance.
func NewMockP2PAPI(ctrl *gomock.Controller) *MockP2PAPI {
	mock := &MockP2PAPI{ctrl: ctrl}
	mock.recorder = &MockP2PAPIMockRecorder{mock}
	return mock
}

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

// AskSecondaryReplicatePieceApproval mocks base method.
func (m *MockP2PAPI) AskSecondaryReplicatePieceApproval(ctx context.Context, task task.ApprovalReplicatePieceTask, low, high int, timeout int64) ([]*gfsptask.GfSpReplicatePieceApprovalTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AskSecondaryReplicatePieceApproval", ctx, task, low, high, timeout)
	ret0, _ := ret[0].([]*gfsptask.GfSpReplicatePieceApprovalTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AskSecondaryReplicatePieceApproval indicates an expected call of AskSecondaryReplicatePieceApproval.
func (mr *MockP2PAPIMockRecorder) AskSecondaryReplicatePieceApproval(ctx, task, low, high, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AskSecondaryReplicatePieceApproval", reflect.TypeOf((*MockP2PAPI)(nil).AskSecondaryReplicatePieceApproval), ctx, task, low, high, timeout)
}

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

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

// MockQueryAPI is a mock of QueryAPI interface.
type MockQueryAPI struct {
	ctrl     *gomock.Controller
	recorder *MockQueryAPIMockRecorder
}

// MockQueryAPIMockRecorder is the mock recorder for MockQueryAPI.
type MockQueryAPIMockRecorder struct {
	mock *MockQueryAPI
}

// NewMockQueryAPI creates a new mock instance.
func NewMockQueryAPI(ctrl *gomock.Controller) *MockQueryAPI {
	mock := &MockQueryAPI{ctrl: ctrl}
	mock.recorder = &MockQueryAPIMockRecorder{mock}
	return mock
}

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

// QueryBucketMigrate mocks base method.
func (m *MockQueryAPI) QueryBucketMigrate(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryBucketMigrate", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QuerySPExit mocks base method.
func (m *MockQueryAPI) QuerySPExit(ctx context.Context, endpoint string, opts ...grpc.DialOption) (string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QuerySPExit", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryTasks mocks base method.
func (m *MockQueryAPI) QueryTasks(ctx context.Context, endpoint, subKey string, opts ...grpc.DialOption) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, endpoint, subKey}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryTasks", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockReceiverAPI is a mock of ReceiverAPI interface.
type MockReceiverAPI struct {
	ctrl     *gomock.Controller
	recorder *MockReceiverAPIMockRecorder
}

// MockReceiverAPIMockRecorder is the mock recorder for MockReceiverAPI.
type MockReceiverAPIMockRecorder struct {
	mock *MockReceiverAPI
}

// NewMockReceiverAPI creates a new mock instance.
func NewMockReceiverAPI(ctrl *gomock.Controller) *MockReceiverAPI {
	mock := &MockReceiverAPI{ctrl: ctrl}
	mock.recorder = &MockReceiverAPIMockRecorder{mock}
	return mock
}

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

// DoneReplicatePiece mocks base method.
func (m *MockReceiverAPI) DoneReplicatePiece(ctx context.Context, task task.ReceivePieceTask, opts ...grpc.DialOption) ([]byte, []byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DoneReplicatePiece", varargs...)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// ReplicatePiece mocks base method.
func (m *MockReceiverAPI) ReplicatePiece(ctx context.Context, task task.ReceivePieceTask, data []byte, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, data}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplicatePiece", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockSignerAPI is a mock of SignerAPI interface.
type MockSignerAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSignerAPIMockRecorder
}

// MockSignerAPIMockRecorder is the mock recorder for MockSignerAPI.
type MockSignerAPIMockRecorder struct {
	mock *MockSignerAPI
}

// NewMockSignerAPI creates a new mock instance.
func NewMockSignerAPI(ctrl *gomock.Controller) *MockSignerAPI {
	mock := &MockSignerAPI{ctrl: ctrl}
	mock.recorder = &MockSignerAPIMockRecorder{mock}
	return mock
}

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

// CompleteMigrateBucket mocks base method.
func (m *MockSignerAPI) CompleteMigrateBucket(ctx context.Context, migrateBucket *types3.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 *MockSignerAPIMockRecorder) CompleteMigrateBucket(ctx, migrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMigrateBucket", reflect.TypeOf((*MockSignerAPI)(nil).CompleteMigrateBucket), ctx, migrateBucket)
}

// CompleteSPExit mocks base method.
func (m *MockSignerAPI) CompleteSPExit(ctx context.Context, completeSPExit *types4.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 *MockSignerAPIMockRecorder) CompleteSPExit(ctx, completeSPExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSPExit", reflect.TypeOf((*MockSignerAPI)(nil).CompleteSPExit), ctx, completeSPExit)
}

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

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

// CompleteSwapOut mocks base method.
func (m *MockSignerAPI) CompleteSwapOut(ctx context.Context, completeSwapOut *types4.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 *MockSignerAPIMockRecorder) CompleteSwapOut(ctx, completeSwapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteSwapOut", reflect.TypeOf((*MockSignerAPI)(nil).CompleteSwapOut), ctx, completeSwapOut)
}

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

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

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

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

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

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

// DeleteGlobalVirtualGroup mocks base method.
func (m *MockSignerAPI) DeleteGlobalVirtualGroup(ctx context.Context, deleteGVG *types4.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 *MockSignerAPIMockRecorder) DeleteGlobalVirtualGroup(ctx, deleteGVG any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalVirtualGroup", reflect.TypeOf((*MockSignerAPI)(nil).DeleteGlobalVirtualGroup), ctx, deleteGVG)
}

// Deposit mocks base method.
func (m *MockSignerAPI) Deposit(ctx context.Context, deposit *types4.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 *MockSignerAPIMockRecorder) Deposit(ctx, deposit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deposit", reflect.TypeOf((*MockSignerAPI)(nil).Deposit), ctx, deposit)
}

// DiscontinueBucket mocks base method.
func (m *MockSignerAPI) DiscontinueBucket(ctx context.Context, bucket *types3.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 *MockSignerAPIMockRecorder) DiscontinueBucket(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscontinueBucket", reflect.TypeOf((*MockSignerAPI)(nil).DiscontinueBucket), ctx, bucket)
}

// RejectMigrateBucket mocks base method.
func (m *MockSignerAPI) RejectMigrateBucket(ctx context.Context, rejectMigrateBucket *types3.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 *MockSignerAPIMockRecorder) RejectMigrateBucket(ctx, rejectMigrateBucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectMigrateBucket", reflect.TypeOf((*MockSignerAPI)(nil).RejectMigrateBucket), ctx, rejectMigrateBucket)
}

// RejectUnSealObject mocks base method.
func (m *MockSignerAPI) RejectUnSealObject(ctx context.Context, object *types3.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 *MockSignerAPIMockRecorder) RejectUnSealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectUnSealObject", reflect.TypeOf((*MockSignerAPI)(nil).RejectUnSealObject), ctx, object)
}

// ReserveSwapIn mocks base method.
func (m *MockSignerAPI) ReserveSwapIn(ctx context.Context, reserveSwapIn *types4.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 *MockSignerAPIMockRecorder) ReserveSwapIn(ctx, reserveSwapIn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReserveSwapIn", reflect.TypeOf((*MockSignerAPI)(nil).ReserveSwapIn), ctx, reserveSwapIn)
}

// SPExit mocks base method.
func (m *MockSignerAPI) SPExit(ctx context.Context, spExit *types4.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 *MockSignerAPIMockRecorder) SPExit(ctx, spExit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPExit", reflect.TypeOf((*MockSignerAPI)(nil).SPExit), ctx, spExit)
}

// SealObject mocks base method.
func (m *MockSignerAPI) SealObject(ctx context.Context, object *types3.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 *MockSignerAPIMockRecorder) SealObject(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObject", reflect.TypeOf((*MockSignerAPI)(nil).SealObject), ctx, object)
}

// SealObjectV2 mocks base method.
func (m *MockSignerAPI) SealObjectV2(ctx context.Context, object *types3.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 *MockSignerAPIMockRecorder) SealObjectV2(ctx, object any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SealObjectV2", reflect.TypeOf((*MockSignerAPI)(nil).SealObjectV2), ctx, object)
}

// SignBucketMigrationInfo mocks base method.
func (m *MockSignerAPI) 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 *MockSignerAPIMockRecorder) SignBucketMigrationInfo(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignBucketMigrationInfo", reflect.TypeOf((*MockSignerAPI)(nil).SignBucketMigrationInfo), ctx, task)
}

// SignCreateBucketApproval mocks base method.
func (m *MockSignerAPI) SignCreateBucketApproval(ctx context.Context, bucket *types3.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 *MockSignerAPIMockRecorder) SignCreateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignCreateBucketApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignCreateBucketApproval), ctx, bucket)
}

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

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

// SignMigrateBucketApproval mocks base method.
func (m *MockSignerAPI) SignMigrateBucketApproval(ctx context.Context, bucket *types3.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 *MockSignerAPIMockRecorder) SignMigrateBucketApproval(ctx, bucket any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateBucketApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignMigrateBucketApproval), ctx, bucket)
}

// SignMigrateGVG mocks base method.
func (m *MockSignerAPI) 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 *MockSignerAPIMockRecorder) SignMigrateGVG(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignMigrateGVG", reflect.TypeOf((*MockSignerAPI)(nil).SignMigrateGVG), ctx, task)
}

// SignP2PPingMsg mocks base method.
func (m *MockSignerAPI) 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 *MockSignerAPIMockRecorder) SignP2PPingMsg(ctx, ping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPingMsg", reflect.TypeOf((*MockSignerAPI)(nil).SignP2PPingMsg), ctx, ping)
}

// SignP2PPongMsg mocks base method.
func (m *MockSignerAPI) 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 *MockSignerAPIMockRecorder) SignP2PPongMsg(ctx, pong any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignP2PPongMsg", reflect.TypeOf((*MockSignerAPI)(nil).SignP2PPongMsg), ctx, pong)
}

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

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

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

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

// SignReplicatePieceApproval mocks base method.
func (m *MockSignerAPI) 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 *MockSignerAPIMockRecorder) SignReplicatePieceApproval(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignReplicatePieceApproval", reflect.TypeOf((*MockSignerAPI)(nil).SignReplicatePieceApproval), ctx, task)
}

// SignSecondarySPMigrationBucket mocks base method.
func (m *MockSignerAPI) SignSecondarySPMigrationBucket(ctx context.Context, signDoc *types3.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 *MockSignerAPIMockRecorder) SignSecondarySPMigrationBucket(ctx, signDoc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSecondarySPMigrationBucket", reflect.TypeOf((*MockSignerAPI)(nil).SignSecondarySPMigrationBucket), ctx, signDoc)
}

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

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

// SignSwapOut mocks base method.
func (m *MockSignerAPI) SignSwapOut(ctx context.Context, swapOut *types4.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 *MockSignerAPIMockRecorder) SignSwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignSwapOut", reflect.TypeOf((*MockSignerAPI)(nil).SignSwapOut), ctx, swapOut)
}

// SwapOut mocks base method.
func (m *MockSignerAPI) SwapOut(ctx context.Context, swapOut *types4.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 *MockSignerAPIMockRecorder) SwapOut(ctx, swapOut any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapOut", reflect.TypeOf((*MockSignerAPI)(nil).SwapOut), ctx, swapOut)
}

// UpdateSPPrice mocks base method.
func (m *MockSignerAPI) UpdateSPPrice(ctx context.Context, price *types2.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 *MockSignerAPIMockRecorder) UpdateSPPrice(ctx, price any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSPPrice", reflect.TypeOf((*MockSignerAPI)(nil).UpdateSPPrice), ctx, price)
}

// MockUploaderAPI is a mock of UploaderAPI interface.
type MockUploaderAPI struct {
	ctrl     *gomock.Controller
	recorder *MockUploaderAPIMockRecorder
}

// MockUploaderAPIMockRecorder is the mock recorder for MockUploaderAPI.
type MockUploaderAPIMockRecorder struct {
	mock *MockUploaderAPI
}

// NewMockUploaderAPI creates a new mock instance.
func NewMockUploaderAPI(ctrl *gomock.Controller) *MockUploaderAPI {
	mock := &MockUploaderAPI{ctrl: ctrl}
	mock.recorder = &MockUploaderAPIMockRecorder{mock}
	return mock
}

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

// ResumableUploadObject mocks base method.
func (m *MockUploaderAPI) ResumableUploadObject(ctx context.Context, task task.ResumableUploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, stream}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResumableUploadObject", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UploadObject mocks base method.
func (m *MockUploaderAPI) UploadObject(ctx context.Context, task task.UploadObjectTask, stream io.Reader, opts ...grpc.DialOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, task, stream}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UploadObject", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockGfSpConnAPI is a mock of GfSpConnAPI interface.
type MockGfSpConnAPI struct {
	ctrl     *gomock.Controller
	recorder *MockGfSpConnAPIMockRecorder
}

// MockGfSpConnAPIMockRecorder is the mock recorder for MockGfSpConnAPI.
type MockGfSpConnAPIMockRecorder struct {
	mock *MockGfSpConnAPI
}

// NewMockGfSpConnAPI creates a new mock instance.
func NewMockGfSpConnAPI(ctrl *gomock.Controller) *MockGfSpConnAPI {
	mock := &MockGfSpConnAPI{ctrl: ctrl}
	mock.recorder = &MockGfSpConnAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Connection mocks base method.
func (m *MockGfSpConnAPI) Connection(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, address}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Connection", varargs...)
	ret0, _ := ret[0].(*grpc.ClientConn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// MockstdLib is a mock of stdLib interface.
type MockstdLib struct {
	ctrl     *gomock.Controller
	recorder *MockstdLibMockRecorder
}

// MockstdLibMockRecorder is the mock recorder for MockstdLib.
type MockstdLibMockRecorder struct {
	mock *MockstdLib
}

// NewMockstdLib creates a new mock instance.
func NewMockstdLib(ctrl *gomock.Controller) *MockstdLib {
	mock := &MockstdLib{ctrl: ctrl}
	mock.recorder = &MockstdLibMockRecorder{mock}
	return mock
}

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

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

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

// Read mocks base method.
func (m *MockstdLib) Read(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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