// Code generated by MockGen. DO NOT EDIT.
// Source: store.go
//
// Generated by this command:
//
//	mockgen -source store.go -destination ../internal/testmocks/store/store_mock.go -package store -typed
//

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

import (
	crypto "crypto"
	reflect "reflect"

	config "codeberg.org/danjones000/combluotion/config"
	activitypub "github.com/go-ap/activitypub"
	filters "github.com/go-ap/filters"
	processing "github.com/go-ap/processing"
	osin "github.com/openshift/osin"
	gomock "go.uber.org/mock/gomock"
)

// MockClientSaver is a mock of ClientSaver interface.
type MockClientSaver struct {
	ctrl     *gomock.Controller
	recorder *MockClientSaverMockRecorder
	isgomock struct{}
}

// MockClientSaverMockRecorder is the mock recorder for MockClientSaver.
type MockClientSaverMockRecorder struct {
	mock *MockClientSaver
}

// NewMockClientSaver creates a new mock instance.
func NewMockClientSaver(ctrl *gomock.Controller) *MockClientSaver {
	mock := &MockClientSaver{ctrl: ctrl}
	mock.recorder = &MockClientSaverMockRecorder{mock}
	return mock
}

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

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

// CreateClient indicates an expected call of CreateClient.
func (mr *MockClientSaverMockRecorder) CreateClient(c any) *MockClientSaverCreateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockClientSaver)(nil).CreateClient), c)
	return &MockClientSaverCreateClientCall{Call: call}
}

// MockClientSaverCreateClientCall wrap *gomock.Call
type MockClientSaverCreateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockClientSaverCreateClientCall) Return(arg0 error) *MockClientSaverCreateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockClientSaverCreateClientCall) Do(f func(osin.Client) error) *MockClientSaverCreateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockClientSaverCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverCreateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}

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

// RemoveClient indicates an expected call of RemoveClient.
func (mr *MockClientSaverMockRecorder) RemoveClient(id any) *MockClientSaverRemoveClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockClientSaver)(nil).RemoveClient), id)
	return &MockClientSaverRemoveClientCall{Call: call}
}

// MockClientSaverRemoveClientCall wrap *gomock.Call
type MockClientSaverRemoveClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClientSaverRemoveClientCall) Return(arg0 error) *MockClientSaverRemoveClientCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClientSaverRemoveClientCall) Do(f func(string) error) *MockClientSaverRemoveClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientSaverRemoveClientCall) DoAndReturn(f func(string) error) *MockClientSaverRemoveClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// UpdateClient indicates an expected call of UpdateClient.
func (mr *MockClientSaverMockRecorder) UpdateClient(c any) *MockClientSaverUpdateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockClientSaver)(nil).UpdateClient), c)
	return &MockClientSaverUpdateClientCall{Call: call}
}

// MockClientSaverUpdateClientCall wrap *gomock.Call
type MockClientSaverUpdateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockClientSaverUpdateClientCall) Return(arg0 error) *MockClientSaverUpdateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockClientSaverUpdateClientCall) Do(f func(osin.Client) error) *MockClientSaverUpdateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockClientSaverUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockClientSaverUpdateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}

// MockClientLister is a mock of ClientLister interface.
type MockClientLister struct {
	ctrl     *gomock.Controller
	recorder *MockClientListerMockRecorder
	isgomock struct{}
}

// MockClientListerMockRecorder is the mock recorder for MockClientLister.
type MockClientListerMockRecorder struct {
	mock *MockClientLister
}

// NewMockClientLister creates a new mock instance.
func NewMockClientLister(ctrl *gomock.Controller) *MockClientLister {
	mock := &MockClientLister{ctrl: ctrl}
	mock.recorder = &MockClientListerMockRecorder{mock}
	return mock
}

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

// GetClient mocks base method.
func (m *MockClientLister) GetClient(id string) (osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient", id)
	ret0, _ := ret[0].(osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClient indicates an expected call of GetClient.
func (mr *MockClientListerMockRecorder) GetClient(id any) *MockClientListerGetClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientLister)(nil).GetClient), id)
	return &MockClientListerGetClientCall{Call: call}
}

// MockClientListerGetClientCall wrap *gomock.Call
type MockClientListerGetClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClientListerGetClientCall) Return(arg0 osin.Client, arg1 error) *MockClientListerGetClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClientListerGetClientCall) Do(f func(string) (osin.Client, error)) *MockClientListerGetClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientListerGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockClientListerGetClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListClients mocks base method.
func (m *MockClientLister) ListClients() ([]osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClients")
	ret0, _ := ret[0].([]osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClients indicates an expected call of ListClients.
func (mr *MockClientListerMockRecorder) ListClients() *MockClientListerListClientsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockClientLister)(nil).ListClients))
	return &MockClientListerListClientsCall{Call: call}
}

// MockClientListerListClientsCall wrap *gomock.Call
type MockClientListerListClientsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClientListerListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockClientListerListClientsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClientListerListClientsCall) Do(f func() ([]osin.Client, error)) *MockClientListerListClientsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientListerListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockClientListerListClientsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockBootstrapper is a mock of Bootstrapper interface.
type MockBootstrapper struct {
	ctrl     *gomock.Controller
	recorder *MockBootstrapperMockRecorder
	isgomock struct{}
}

// MockBootstrapperMockRecorder is the mock recorder for MockBootstrapper.
type MockBootstrapperMockRecorder struct {
	mock *MockBootstrapper
}

// NewMockBootstrapper creates a new mock instance.
func NewMockBootstrapper(ctrl *gomock.Controller) *MockBootstrapper {
	mock := &MockBootstrapper{ctrl: ctrl}
	mock.recorder = &MockBootstrapperMockRecorder{mock}
	return mock
}

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

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

// Bootstrap indicates an expected call of Bootstrap.
func (mr *MockBootstrapperMockRecorder) Bootstrap(arg0 any) *MockBootstrapperBootstrapCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockBootstrapper)(nil).Bootstrap), arg0)
	return &MockBootstrapperBootstrapCall{Call: call}
}

// MockBootstrapperBootstrapCall wrap *gomock.Call
type MockBootstrapperBootstrapCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBootstrapperBootstrapCall) Return(arg0 error) *MockBootstrapperBootstrapCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBootstrapperBootstrapCall) Do(f func(config.Config) error) *MockBootstrapperBootstrapCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBootstrapperBootstrapCall) DoAndReturn(f func(config.Config) error) *MockBootstrapperBootstrapCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// AddTo mocks base method.
func (m *MockStore) AddTo(col activitypub.IRI, it activitypub.Item) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTo", col, it)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddTo indicates an expected call of AddTo.
func (mr *MockStoreMockRecorder) AddTo(col, it any) *MockStoreAddToCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockStore)(nil).AddTo), col, it)
	return &MockStoreAddToCall{Call: call}
}

// MockStoreAddToCall wrap *gomock.Call
type MockStoreAddToCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreAddToCall) Return(arg0 error) *MockStoreAddToCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreAddToCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Bootstrap indicates an expected call of Bootstrap.
func (mr *MockStoreMockRecorder) Bootstrap(arg0 any) *MockStoreBootstrapCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bootstrap", reflect.TypeOf((*MockStore)(nil).Bootstrap), arg0)
	return &MockStoreBootstrapCall{Call: call}
}

// MockStoreBootstrapCall wrap *gomock.Call
type MockStoreBootstrapCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreBootstrapCall) Return(arg0 error) *MockStoreBootstrapCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreBootstrapCall) Do(f func(config.Config) error) *MockStoreBootstrapCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreBootstrapCall) DoAndReturn(f func(config.Config) error) *MockStoreBootstrapCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Clone mocks base method.
func (m *MockStore) Clone() osin.Storage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone")
	ret0, _ := ret[0].(osin.Storage)
	return ret0
}

// Clone indicates an expected call of Clone.
func (mr *MockStoreMockRecorder) Clone() *MockStoreCloneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockStore)(nil).Clone))
	return &MockStoreCloneCall{Call: call}
}

// MockStoreCloneCall wrap *gomock.Call
type MockStoreCloneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreCloneCall) Return(arg0 osin.Storage) *MockStoreCloneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreCloneCall) Do(f func() osin.Storage) *MockStoreCloneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockStoreCloneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Close mocks base method.
func (m *MockStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockStoreMockRecorder) Close() *MockStoreCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close))
	return &MockStoreCloseCall{Call: call}
}

// MockStoreCloseCall wrap *gomock.Call
type MockStoreCloseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreCloseCall) Return() *MockStoreCloseCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreCloseCall) Do(f func()) *MockStoreCloseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreCloseCall) DoAndReturn(f func()) *MockStoreCloseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Create mocks base method.
func (m *MockStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", col)
	ret0, _ := ret[0].(activitypub.CollectionInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockStoreMockRecorder) Create(col any) *MockStoreCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStore)(nil).Create), col)
	return &MockStoreCreateCall{Call: call}
}

// MockStoreCreateCall wrap *gomock.Call
type MockStoreCreateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockStoreCreateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockStoreCreateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// CreateClient indicates an expected call of CreateClient.
func (mr *MockStoreMockRecorder) CreateClient(c any) *MockStoreCreateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockStore)(nil).CreateClient), c)
	return &MockStoreCreateClientCall{Call: call}
}

// MockStoreCreateClientCall wrap *gomock.Call
type MockStoreCreateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockStoreCreateClientCall) Return(arg0 error) *MockStoreCreateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockStoreCreateClientCall) Do(f func(osin.Client) error) *MockStoreCreateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreCreateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}

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

// Delete indicates an expected call of Delete.
func (mr *MockStoreMockRecorder) Delete(arg0 any) *MockStoreDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStore)(nil).Delete), arg0)
	return &MockStoreDeleteCall{Call: call}
}

// MockStoreDeleteCall wrap *gomock.Call
type MockStoreDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreDeleteCall) Return(arg0 error) *MockStoreDeleteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreDeleteCall) Do(f func(activitypub.Item) error) *MockStoreDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockStoreDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClient mocks base method.
func (m *MockStore) GetClient(id string) (osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient", id)
	ret0, _ := ret[0].(osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClient indicates an expected call of GetClient.
func (mr *MockStoreMockRecorder) GetClient(id any) *MockStoreGetClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockStore)(nil).GetClient), id)
	return &MockStoreGetClientCall{Call: call}
}

// MockStoreGetClientCall wrap *gomock.Call
type MockStoreGetClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockStoreGetClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockStoreGetClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockStoreGetClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListClients mocks base method.
func (m *MockStore) ListClients() ([]osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClients")
	ret0, _ := ret[0].([]osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClients indicates an expected call of ListClients.
func (mr *MockStoreMockRecorder) ListClients() *MockStoreListClientsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockStore)(nil).ListClients))
	return &MockStoreListClientsCall{Call: call}
}

// MockStoreListClientsCall wrap *gomock.Call
type MockStoreListClientsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockStoreListClientsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockStoreListClientsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockStoreListClientsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Load mocks base method.
func (m *MockStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Load", varargs...)
	ret0, _ := ret[0].(activitypub.Item)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Load indicates an expected call of Load.
func (mr *MockStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockStoreLoadCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockStore)(nil).Load), varargs...)
	return &MockStoreLoadCall{Call: call}
}

// MockStoreLoadCall wrap *gomock.Call
type MockStoreLoadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreLoadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockStoreLoadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadAccess mocks base method.
func (m *MockStore) LoadAccess(token string) (*osin.AccessData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadAccess", token)
	ret0, _ := ret[0].(*osin.AccessData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadAccess indicates an expected call of LoadAccess.
func (mr *MockStoreMockRecorder) LoadAccess(token any) *MockStoreLoadAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockStore)(nil).LoadAccess), token)
	return &MockStoreLoadAccessCall{Call: call}
}

// MockStoreLoadAccessCall wrap *gomock.Call
type MockStoreLoadAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadAccessCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadAuthorize mocks base method.
func (m *MockStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadAuthorize", code)
	ret0, _ := ret[0].(*osin.AuthorizeData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadAuthorize indicates an expected call of LoadAuthorize.
func (mr *MockStoreMockRecorder) LoadAuthorize(code any) *MockStoreLoadAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockStore)(nil).LoadAuthorize), code)
	return &MockStoreLoadAuthorizeCall{Call: call}
}

// MockStoreLoadAuthorizeCall wrap *gomock.Call
type MockStoreLoadAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockStoreLoadAuthorizeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockStoreLoadAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadKey mocks base method.
func (m *MockStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadKey", arg0)
	ret0, _ := ret[0].(crypto.PrivateKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadKey indicates an expected call of LoadKey.
func (mr *MockStoreMockRecorder) LoadKey(arg0 any) *MockStoreLoadKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockStore)(nil).LoadKey), arg0)
	return &MockStoreLoadKeyCall{Call: call}
}

// MockStoreLoadKeyCall wrap *gomock.Call
type MockStoreLoadKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockStoreLoadKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockStoreLoadKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadMetadata mocks base method.
func (m *MockStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadMetadata", arg0)
	ret0, _ := ret[0].(*processing.Metadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadMetadata indicates an expected call of LoadMetadata.
func (mr *MockStoreMockRecorder) LoadMetadata(arg0 any) *MockStoreLoadMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockStore)(nil).LoadMetadata), arg0)
	return &MockStoreLoadMetadataCall{Call: call}
}

// MockStoreLoadMetadataCall wrap *gomock.Call
type MockStoreLoadMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockStoreLoadMetadataCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockStoreLoadMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadRefresh mocks base method.
func (m *MockStore) LoadRefresh(token string) (*osin.AccessData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadRefresh", token)
	ret0, _ := ret[0].(*osin.AccessData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadRefresh indicates an expected call of LoadRefresh.
func (mr *MockStoreMockRecorder) LoadRefresh(token any) *MockStoreLoadRefreshCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockStore)(nil).LoadRefresh), token)
	return &MockStoreLoadRefreshCall{Call: call}
}

// MockStoreLoadRefreshCall wrap *gomock.Call
type MockStoreLoadRefreshCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockStoreLoadRefreshCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockStoreLoadRefreshCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveAccess indicates an expected call of RemoveAccess.
func (mr *MockStoreMockRecorder) RemoveAccess(token any) *MockStoreRemoveAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockStore)(nil).RemoveAccess), token)
	return &MockStoreRemoveAccessCall{Call: call}
}

// MockStoreRemoveAccessCall wrap *gomock.Call
type MockStoreRemoveAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreRemoveAccessCall) Return(arg0 error) *MockStoreRemoveAccessCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreRemoveAccessCall) Do(f func(string) error) *MockStoreRemoveAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockStoreRemoveAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveAuthorize indicates an expected call of RemoveAuthorize.
func (mr *MockStoreMockRecorder) RemoveAuthorize(code any) *MockStoreRemoveAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockStore)(nil).RemoveAuthorize), code)
	return &MockStoreRemoveAuthorizeCall{Call: call}
}

// MockStoreRemoveAuthorizeCall wrap *gomock.Call
type MockStoreRemoveAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreRemoveAuthorizeCall) Return(arg0 error) *MockStoreRemoveAuthorizeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreRemoveAuthorizeCall) Do(f func(string) error) *MockStoreRemoveAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockStoreRemoveAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveClient indicates an expected call of RemoveClient.
func (mr *MockStoreMockRecorder) RemoveClient(id any) *MockStoreRemoveClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockStore)(nil).RemoveClient), id)
	return &MockStoreRemoveClientCall{Call: call}
}

// MockStoreRemoveClientCall wrap *gomock.Call
type MockStoreRemoveClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreRemoveClientCall) Return(arg0 error) *MockStoreRemoveClientCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreRemoveClientCall) Do(f func(string) error) *MockStoreRemoveClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockStoreRemoveClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveFrom mocks base method.
func (m *MockStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFrom", col, it)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveFrom indicates an expected call of RemoveFrom.
func (mr *MockStoreMockRecorder) RemoveFrom(col, it any) *MockStoreRemoveFromCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockStore)(nil).RemoveFrom), col, it)
	return &MockStoreRemoveFromCall{Call: call}
}

// MockStoreRemoveFromCall wrap *gomock.Call
type MockStoreRemoveFromCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreRemoveFromCall) Return(arg0 error) *MockStoreRemoveFromCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockStoreRemoveFromCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveRefresh indicates an expected call of RemoveRefresh.
func (mr *MockStoreMockRecorder) RemoveRefresh(token any) *MockStoreRemoveRefreshCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockStore)(nil).RemoveRefresh), token)
	return &MockStoreRemoveRefreshCall{Call: call}
}

// MockStoreRemoveRefreshCall wrap *gomock.Call
type MockStoreRemoveRefreshCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreRemoveRefreshCall) Return(arg0 error) *MockStoreRemoveRefreshCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreRemoveRefreshCall) Do(f func(string) error) *MockStoreRemoveRefreshCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockStoreRemoveRefreshCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Save mocks base method.
func (m *MockStore) Save(arg0 activitypub.Item) (activitypub.Item, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", arg0)
	ret0, _ := ret[0].(activitypub.Item)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockStoreMockRecorder) Save(arg0 any) *MockStoreSaveCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStore)(nil).Save), arg0)
	return &MockStoreSaveCall{Call: call}
}

// MockStoreSaveCall wrap *gomock.Call
type MockStoreSaveCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockStoreSaveCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockStoreSaveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SaveAccess indicates an expected call of SaveAccess.
func (mr *MockStoreMockRecorder) SaveAccess(arg0 any) *MockStoreSaveAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockStore)(nil).SaveAccess), arg0)
	return &MockStoreSaveAccessCall{Call: call}
}

// MockStoreSaveAccessCall wrap *gomock.Call
type MockStoreSaveAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreSaveAccessCall) Return(arg0 error) *MockStoreSaveAccessCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockStoreSaveAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockStoreSaveAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SaveAuthorize indicates an expected call of SaveAuthorize.
func (mr *MockStoreMockRecorder) SaveAuthorize(arg0 any) *MockStoreSaveAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockStore)(nil).SaveAuthorize), arg0)
	return &MockStoreSaveAuthorizeCall{Call: call}
}

// MockStoreSaveAuthorizeCall wrap *gomock.Call
type MockStoreSaveAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreSaveAuthorizeCall) Return(arg0 error) *MockStoreSaveAuthorizeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockStoreSaveAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SaveMetadata mocks base method.
func (m *MockStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveMetadata indicates an expected call of SaveMetadata.
func (mr *MockStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockStoreSaveMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockStore)(nil).SaveMetadata), arg0, arg1)
	return &MockStoreSaveMetadataCall{Call: call}
}

// MockStoreSaveMetadataCall wrap *gomock.Call
type MockStoreSaveMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockStoreSaveMetadataCall) Return(arg0 error) *MockStoreSaveMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockStoreSaveMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// UpdateClient indicates an expected call of UpdateClient.
func (mr *MockStoreMockRecorder) UpdateClient(c any) *MockStoreUpdateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockStore)(nil).UpdateClient), c)
	return &MockStoreUpdateClientCall{Call: call}
}

// MockStoreUpdateClientCall wrap *gomock.Call
type MockStoreUpdateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockStoreUpdateClientCall) Return(arg0 error) *MockStoreUpdateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockStoreUpdateClientCall) Do(f func(osin.Client) error) *MockStoreUpdateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockStoreUpdateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}

// MockPartStore is a mock of PartStore interface.
type MockPartStore struct {
	ctrl     *gomock.Controller
	recorder *MockPartStoreMockRecorder
	isgomock struct{}
}

// MockPartStoreMockRecorder is the mock recorder for MockPartStore.
type MockPartStoreMockRecorder struct {
	mock *MockPartStore
}

// NewMockPartStore creates a new mock instance.
func NewMockPartStore(ctrl *gomock.Controller) *MockPartStore {
	mock := &MockPartStore{ctrl: ctrl}
	mock.recorder = &MockPartStoreMockRecorder{mock}
	return mock
}

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

// AddTo mocks base method.
func (m *MockPartStore) AddTo(col activitypub.IRI, it activitypub.Item) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTo", col, it)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddTo indicates an expected call of AddTo.
func (mr *MockPartStoreMockRecorder) AddTo(col, it any) *MockPartStoreAddToCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTo", reflect.TypeOf((*MockPartStore)(nil).AddTo), col, it)
	return &MockPartStoreAddToCall{Call: call}
}

// MockPartStoreAddToCall wrap *gomock.Call
type MockPartStoreAddToCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreAddToCall) Return(arg0 error) *MockPartStoreAddToCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreAddToCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreAddToCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreAddToCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Clone mocks base method.
func (m *MockPartStore) Clone() osin.Storage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone")
	ret0, _ := ret[0].(osin.Storage)
	return ret0
}

// Clone indicates an expected call of Clone.
func (mr *MockPartStoreMockRecorder) Clone() *MockPartStoreCloneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockPartStore)(nil).Clone))
	return &MockPartStoreCloneCall{Call: call}
}

// MockPartStoreCloneCall wrap *gomock.Call
type MockPartStoreCloneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreCloneCall) Return(arg0 osin.Storage) *MockPartStoreCloneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreCloneCall) Do(f func() osin.Storage) *MockPartStoreCloneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreCloneCall) DoAndReturn(f func() osin.Storage) *MockPartStoreCloneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Close mocks base method.
func (m *MockPartStore) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockPartStoreMockRecorder) Close() *MockPartStoreCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPartStore)(nil).Close))
	return &MockPartStoreCloseCall{Call: call}
}

// MockPartStoreCloseCall wrap *gomock.Call
type MockPartStoreCloseCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreCloseCall) Return() *MockPartStoreCloseCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreCloseCall) Do(f func()) *MockPartStoreCloseCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreCloseCall) DoAndReturn(f func()) *MockPartStoreCloseCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Create mocks base method.
func (m *MockPartStore) Create(col activitypub.CollectionInterface) (activitypub.CollectionInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", col)
	ret0, _ := ret[0].(activitypub.CollectionInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockPartStoreMockRecorder) Create(col any) *MockPartStoreCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPartStore)(nil).Create), col)
	return &MockPartStoreCreateCall{Call: call}
}

// MockPartStoreCreateCall wrap *gomock.Call
type MockPartStoreCreateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreCreateCall) Return(arg0 activitypub.CollectionInterface, arg1 error) *MockPartStoreCreateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreCreateCall) Do(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreCreateCall) DoAndReturn(f func(activitypub.CollectionInterface) (activitypub.CollectionInterface, error)) *MockPartStoreCreateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// CreateClient indicates an expected call of CreateClient.
func (mr *MockPartStoreMockRecorder) CreateClient(c any) *MockPartStoreCreateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClient", reflect.TypeOf((*MockPartStore)(nil).CreateClient), c)
	return &MockPartStoreCreateClientCall{Call: call}
}

// MockPartStoreCreateClientCall wrap *gomock.Call
type MockPartStoreCreateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockPartStoreCreateClientCall) Return(arg0 error) *MockPartStoreCreateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockPartStoreCreateClientCall) Do(f func(osin.Client) error) *MockPartStoreCreateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockPartStoreCreateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreCreateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}

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

// Delete indicates an expected call of Delete.
func (mr *MockPartStoreMockRecorder) Delete(arg0 any) *MockPartStoreDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPartStore)(nil).Delete), arg0)
	return &MockPartStoreDeleteCall{Call: call}
}

// MockPartStoreDeleteCall wrap *gomock.Call
type MockPartStoreDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreDeleteCall) Return(arg0 error) *MockPartStoreDeleteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreDeleteCall) Do(f func(activitypub.Item) error) *MockPartStoreDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreDeleteCall) DoAndReturn(f func(activitypub.Item) error) *MockPartStoreDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClient mocks base method.
func (m *MockPartStore) GetClient(id string) (osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient", id)
	ret0, _ := ret[0].(osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClient indicates an expected call of GetClient.
func (mr *MockPartStoreMockRecorder) GetClient(id any) *MockPartStoreGetClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockPartStore)(nil).GetClient), id)
	return &MockPartStoreGetClientCall{Call: call}
}

// MockPartStoreGetClientCall wrap *gomock.Call
type MockPartStoreGetClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreGetClientCall) Return(arg0 osin.Client, arg1 error) *MockPartStoreGetClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreGetClientCall) Do(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreGetClientCall) DoAndReturn(f func(string) (osin.Client, error)) *MockPartStoreGetClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListClients mocks base method.
func (m *MockPartStore) ListClients() ([]osin.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClients")
	ret0, _ := ret[0].([]osin.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClients indicates an expected call of ListClients.
func (mr *MockPartStoreMockRecorder) ListClients() *MockPartStoreListClientsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClients", reflect.TypeOf((*MockPartStore)(nil).ListClients))
	return &MockPartStoreListClientsCall{Call: call}
}

// MockPartStoreListClientsCall wrap *gomock.Call
type MockPartStoreListClientsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreListClientsCall) Return(arg0 []osin.Client, arg1 error) *MockPartStoreListClientsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreListClientsCall) Do(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreListClientsCall) DoAndReturn(f func() ([]osin.Client, error)) *MockPartStoreListClientsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Load mocks base method.
func (m *MockPartStore) Load(arg0 activitypub.IRI, arg1 ...filters.Check) (activitypub.Item, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Load", varargs...)
	ret0, _ := ret[0].(activitypub.Item)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Load indicates an expected call of Load.
func (mr *MockPartStoreMockRecorder) Load(arg0 any, arg1 ...any) *MockPartStoreLoadCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockPartStore)(nil).Load), varargs...)
	return &MockPartStoreLoadCall{Call: call}
}

// MockPartStoreLoadCall wrap *gomock.Call
type MockPartStoreLoadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreLoadCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadCall) Do(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadCall) DoAndReturn(f func(activitypub.IRI, ...filters.Check) (activitypub.Item, error)) *MockPartStoreLoadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadAccess mocks base method.
func (m *MockPartStore) LoadAccess(token string) (*osin.AccessData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadAccess", token)
	ret0, _ := ret[0].(*osin.AccessData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadAccess indicates an expected call of LoadAccess.
func (mr *MockPartStoreMockRecorder) LoadAccess(token any) *MockPartStoreLoadAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAccess", reflect.TypeOf((*MockPartStore)(nil).LoadAccess), token)
	return &MockPartStoreLoadAccessCall{Call: call}
}

// MockPartStoreLoadAccessCall wrap *gomock.Call
type MockPartStoreLoadAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadAccessCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadAccessCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadAccessCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadAccessCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadAuthorize mocks base method.
func (m *MockPartStore) LoadAuthorize(code string) (*osin.AuthorizeData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadAuthorize", code)
	ret0, _ := ret[0].(*osin.AuthorizeData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadAuthorize indicates an expected call of LoadAuthorize.
func (mr *MockPartStoreMockRecorder) LoadAuthorize(code any) *MockPartStoreLoadAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadAuthorize", reflect.TypeOf((*MockPartStore)(nil).LoadAuthorize), code)
	return &MockPartStoreLoadAuthorizeCall{Call: call}
}

// MockPartStoreLoadAuthorizeCall wrap *gomock.Call
type MockPartStoreLoadAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadAuthorizeCall) Return(arg0 *osin.AuthorizeData, arg1 error) *MockPartStoreLoadAuthorizeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadAuthorizeCall) Do(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadAuthorizeCall) DoAndReturn(f func(string) (*osin.AuthorizeData, error)) *MockPartStoreLoadAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadKey mocks base method.
func (m *MockPartStore) LoadKey(arg0 activitypub.IRI) (crypto.PrivateKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadKey", arg0)
	ret0, _ := ret[0].(crypto.PrivateKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadKey indicates an expected call of LoadKey.
func (mr *MockPartStoreMockRecorder) LoadKey(arg0 any) *MockPartStoreLoadKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKey", reflect.TypeOf((*MockPartStore)(nil).LoadKey), arg0)
	return &MockPartStoreLoadKeyCall{Call: call}
}

// MockPartStoreLoadKeyCall wrap *gomock.Call
type MockPartStoreLoadKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadKeyCall) Return(arg0 crypto.PrivateKey, arg1 error) *MockPartStoreLoadKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadKeyCall) Do(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadKeyCall) DoAndReturn(f func(activitypub.IRI) (crypto.PrivateKey, error)) *MockPartStoreLoadKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadMetadata mocks base method.
func (m *MockPartStore) LoadMetadata(arg0 activitypub.IRI) (*processing.Metadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadMetadata", arg0)
	ret0, _ := ret[0].(*processing.Metadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadMetadata indicates an expected call of LoadMetadata.
func (mr *MockPartStoreMockRecorder) LoadMetadata(arg0 any) *MockPartStoreLoadMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockPartStore)(nil).LoadMetadata), arg0)
	return &MockPartStoreLoadMetadataCall{Call: call}
}

// MockPartStoreLoadMetadataCall wrap *gomock.Call
type MockPartStoreLoadMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadMetadataCall) Return(arg0 *processing.Metadata, arg1 error) *MockPartStoreLoadMetadataCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadMetadataCall) Do(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadMetadataCall) DoAndReturn(f func(activitypub.IRI) (*processing.Metadata, error)) *MockPartStoreLoadMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LoadRefresh mocks base method.
func (m *MockPartStore) LoadRefresh(token string) (*osin.AccessData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadRefresh", token)
	ret0, _ := ret[0].(*osin.AccessData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadRefresh indicates an expected call of LoadRefresh.
func (mr *MockPartStoreMockRecorder) LoadRefresh(token any) *MockPartStoreLoadRefreshCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadRefresh", reflect.TypeOf((*MockPartStore)(nil).LoadRefresh), token)
	return &MockPartStoreLoadRefreshCall{Call: call}
}

// MockPartStoreLoadRefreshCall wrap *gomock.Call
type MockPartStoreLoadRefreshCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreLoadRefreshCall) Return(arg0 *osin.AccessData, arg1 error) *MockPartStoreLoadRefreshCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreLoadRefreshCall) Do(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreLoadRefreshCall) DoAndReturn(f func(string) (*osin.AccessData, error)) *MockPartStoreLoadRefreshCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveAccess indicates an expected call of RemoveAccess.
func (mr *MockPartStoreMockRecorder) RemoveAccess(token any) *MockPartStoreRemoveAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAccess", reflect.TypeOf((*MockPartStore)(nil).RemoveAccess), token)
	return &MockPartStoreRemoveAccessCall{Call: call}
}

// MockPartStoreRemoveAccessCall wrap *gomock.Call
type MockPartStoreRemoveAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreRemoveAccessCall) Return(arg0 error) *MockPartStoreRemoveAccessCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreRemoveAccessCall) Do(f func(string) error) *MockPartStoreRemoveAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreRemoveAccessCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveAuthorize indicates an expected call of RemoveAuthorize.
func (mr *MockPartStoreMockRecorder) RemoveAuthorize(code any) *MockPartStoreRemoveAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAuthorize", reflect.TypeOf((*MockPartStore)(nil).RemoveAuthorize), code)
	return &MockPartStoreRemoveAuthorizeCall{Call: call}
}

// MockPartStoreRemoveAuthorizeCall wrap *gomock.Call
type MockPartStoreRemoveAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreRemoveAuthorizeCall) Return(arg0 error) *MockPartStoreRemoveAuthorizeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreRemoveAuthorizeCall) Do(f func(string) error) *MockPartStoreRemoveAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreRemoveAuthorizeCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveClient indicates an expected call of RemoveClient.
func (mr *MockPartStoreMockRecorder) RemoveClient(id any) *MockPartStoreRemoveClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClient", reflect.TypeOf((*MockPartStore)(nil).RemoveClient), id)
	return &MockPartStoreRemoveClientCall{Call: call}
}

// MockPartStoreRemoveClientCall wrap *gomock.Call
type MockPartStoreRemoveClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreRemoveClientCall) Return(arg0 error) *MockPartStoreRemoveClientCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreRemoveClientCall) Do(f func(string) error) *MockPartStoreRemoveClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreRemoveClientCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RemoveFrom mocks base method.
func (m *MockPartStore) RemoveFrom(col activitypub.IRI, it activitypub.Item) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFrom", col, it)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveFrom indicates an expected call of RemoveFrom.
func (mr *MockPartStoreMockRecorder) RemoveFrom(col, it any) *MockPartStoreRemoveFromCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFrom", reflect.TypeOf((*MockPartStore)(nil).RemoveFrom), col, it)
	return &MockPartStoreRemoveFromCall{Call: call}
}

// MockPartStoreRemoveFromCall wrap *gomock.Call
type MockPartStoreRemoveFromCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreRemoveFromCall) Return(arg0 error) *MockPartStoreRemoveFromCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreRemoveFromCall) Do(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreRemoveFromCall) DoAndReturn(f func(activitypub.IRI, activitypub.Item) error) *MockPartStoreRemoveFromCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveRefresh indicates an expected call of RemoveRefresh.
func (mr *MockPartStoreMockRecorder) RemoveRefresh(token any) *MockPartStoreRemoveRefreshCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRefresh", reflect.TypeOf((*MockPartStore)(nil).RemoveRefresh), token)
	return &MockPartStoreRemoveRefreshCall{Call: call}
}

// MockPartStoreRemoveRefreshCall wrap *gomock.Call
type MockPartStoreRemoveRefreshCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreRemoveRefreshCall) Return(arg0 error) *MockPartStoreRemoveRefreshCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreRemoveRefreshCall) Do(f func(string) error) *MockPartStoreRemoveRefreshCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreRemoveRefreshCall) DoAndReturn(f func(string) error) *MockPartStoreRemoveRefreshCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Save mocks base method.
func (m *MockPartStore) Save(arg0 activitypub.Item) (activitypub.Item, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", arg0)
	ret0, _ := ret[0].(activitypub.Item)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Save indicates an expected call of Save.
func (mr *MockPartStoreMockRecorder) Save(arg0 any) *MockPartStoreSaveCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockPartStore)(nil).Save), arg0)
	return &MockPartStoreSaveCall{Call: call}
}

// MockPartStoreSaveCall wrap *gomock.Call
type MockPartStoreSaveCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreSaveCall) Return(arg0 activitypub.Item, arg1 error) *MockPartStoreSaveCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreSaveCall) Do(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreSaveCall) DoAndReturn(f func(activitypub.Item) (activitypub.Item, error)) *MockPartStoreSaveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SaveAccess indicates an expected call of SaveAccess.
func (mr *MockPartStoreMockRecorder) SaveAccess(arg0 any) *MockPartStoreSaveAccessCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAccess", reflect.TypeOf((*MockPartStore)(nil).SaveAccess), arg0)
	return &MockPartStoreSaveAccessCall{Call: call}
}

// MockPartStoreSaveAccessCall wrap *gomock.Call
type MockPartStoreSaveAccessCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreSaveAccessCall) Return(arg0 error) *MockPartStoreSaveAccessCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreSaveAccessCall) Do(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreSaveAccessCall) DoAndReturn(f func(*osin.AccessData) error) *MockPartStoreSaveAccessCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SaveAuthorize indicates an expected call of SaveAuthorize.
func (mr *MockPartStoreMockRecorder) SaveAuthorize(arg0 any) *MockPartStoreSaveAuthorizeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorize", reflect.TypeOf((*MockPartStore)(nil).SaveAuthorize), arg0)
	return &MockPartStoreSaveAuthorizeCall{Call: call}
}

// MockPartStoreSaveAuthorizeCall wrap *gomock.Call
type MockPartStoreSaveAuthorizeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreSaveAuthorizeCall) Return(arg0 error) *MockPartStoreSaveAuthorizeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreSaveAuthorizeCall) Do(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreSaveAuthorizeCall) DoAndReturn(f func(*osin.AuthorizeData) error) *MockPartStoreSaveAuthorizeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SaveMetadata mocks base method.
func (m *MockPartStore) SaveMetadata(arg0 processing.Metadata, arg1 activitypub.IRI) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveMetadata", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveMetadata indicates an expected call of SaveMetadata.
func (mr *MockPartStoreMockRecorder) SaveMetadata(arg0, arg1 any) *MockPartStoreSaveMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetadata", reflect.TypeOf((*MockPartStore)(nil).SaveMetadata), arg0, arg1)
	return &MockPartStoreSaveMetadataCall{Call: call}
}

// MockPartStoreSaveMetadataCall wrap *gomock.Call
type MockPartStoreSaveMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPartStoreSaveMetadataCall) Return(arg0 error) *MockPartStoreSaveMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPartStoreSaveMetadataCall) Do(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPartStoreSaveMetadataCall) DoAndReturn(f func(processing.Metadata, activitypub.IRI) error) *MockPartStoreSaveMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// UpdateClient indicates an expected call of UpdateClient.
func (mr *MockPartStoreMockRecorder) UpdateClient(c any) *MockPartStoreUpdateClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClient", reflect.TypeOf((*MockPartStore)(nil).UpdateClient), c)
	return &MockPartStoreUpdateClientCall{Call: call}
}

// MockPartStoreUpdateClientCall wrap *gomock.Call
type MockPartStoreUpdateClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c_2 *MockPartStoreUpdateClientCall) Return(arg0 error) *MockPartStoreUpdateClientCall {
	c_2.Call = c_2.Call.Return(arg0)
	return c_2
}

// Do rewrite *gomock.Call.Do
func (c_2 *MockPartStoreUpdateClientCall) Do(f func(osin.Client) error) *MockPartStoreUpdateClientCall {
	c_2.Call = c_2.Call.Do(f)
	return c_2
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c_2 *MockPartStoreUpdateClientCall) DoAndReturn(f func(osin.Client) error) *MockPartStoreUpdateClientCall {
	c_2.Call = c_2.Call.DoAndReturn(f)
	return c_2
}