// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/storage/storage.go
//
// Generated by this command:
//
//	mockgen -source pkg/storage/storage.go -destination internal/mocks/mock_storage.go -package mocks OpenFGADatastore
//

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

import (
	context "context"
	reflect "reflect"

	openfgav1 "github.com/openfga/api/proto/openfga/v1"
	storage "github.com/openfga/openfga/pkg/storage"
	gomock "go.uber.org/mock/gomock"
)

// MockTupleBackend is a mock of TupleBackend interface.
type MockTupleBackend struct {
	ctrl     *gomock.Controller
	recorder *MockTupleBackendMockRecorder
	isgomock struct{}
}

// MockTupleBackendMockRecorder is the mock recorder for MockTupleBackend.
type MockTupleBackendMockRecorder struct {
	mock *MockTupleBackend
}

// NewMockTupleBackend creates a new mock instance.
func NewMockTupleBackend(ctrl *gomock.Controller) *MockTupleBackend {
	mock := &MockTupleBackend{ctrl: ctrl}
	mock.recorder = &MockTupleBackendMockRecorder{mock}
	return mock
}

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

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

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

// Read mocks base method.
func (m *MockTupleBackend) Read(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockTupleBackendMockRecorder) Read(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockTupleBackend)(nil).Read), ctx, store, filter, options)
}

// ReadPage mocks base method.
func (m *MockTupleBackend) ReadPage(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadPageOptions) ([]*openfgav1.Tuple, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadPage", ctx, store, filter, options)
	ret0, _ := ret[0].([]*openfgav1.Tuple)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadPage indicates an expected call of ReadPage.
func (mr *MockTupleBackendMockRecorder) ReadPage(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPage", reflect.TypeOf((*MockTupleBackend)(nil).ReadPage), ctx, store, filter, options)
}

// ReadStartingWithUser mocks base method.
func (m *MockTupleBackend) ReadStartingWithUser(ctx context.Context, store string, filter storage.ReadStartingWithUserFilter, options storage.ReadStartingWithUserOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStartingWithUser", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadStartingWithUser indicates an expected call of ReadStartingWithUser.
func (mr *MockTupleBackendMockRecorder) ReadStartingWithUser(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStartingWithUser", reflect.TypeOf((*MockTupleBackend)(nil).ReadStartingWithUser), ctx, store, filter, options)
}

// ReadUserTuple mocks base method.
func (m *MockTupleBackend) ReadUserTuple(ctx context.Context, store string, filter storage.ReadUserTupleFilter, options storage.ReadUserTupleOptions) (*openfgav1.Tuple, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUserTuple", ctx, store, filter, options)
	ret0, _ := ret[0].(*openfgav1.Tuple)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUserTuple indicates an expected call of ReadUserTuple.
func (mr *MockTupleBackendMockRecorder) ReadUserTuple(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUserTuple", reflect.TypeOf((*MockTupleBackend)(nil).ReadUserTuple), ctx, store, filter, options)
}

// ReadUsersetTuples mocks base method.
func (m *MockTupleBackend) ReadUsersetTuples(ctx context.Context, store string, filter storage.ReadUsersetTuplesFilter, options storage.ReadUsersetTuplesOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUsersetTuples", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUsersetTuples indicates an expected call of ReadUsersetTuples.
func (mr *MockTupleBackendMockRecorder) ReadUsersetTuples(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUsersetTuples", reflect.TypeOf((*MockTupleBackend)(nil).ReadUsersetTuples), ctx, store, filter, options)
}

// Write mocks base method.
func (m *MockTupleBackend) Write(ctx context.Context, store string, d storage.Deletes, w storage.Writes, opts ...storage.TupleWriteOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, store, d, w}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockRelationshipTupleReader is a mock of RelationshipTupleReader interface.
type MockRelationshipTupleReader struct {
	ctrl     *gomock.Controller
	recorder *MockRelationshipTupleReaderMockRecorder
	isgomock struct{}
}

// MockRelationshipTupleReaderMockRecorder is the mock recorder for MockRelationshipTupleReader.
type MockRelationshipTupleReaderMockRecorder struct {
	mock *MockRelationshipTupleReader
}

// NewMockRelationshipTupleReader creates a new mock instance.
func NewMockRelationshipTupleReader(ctrl *gomock.Controller) *MockRelationshipTupleReader {
	mock := &MockRelationshipTupleReader{ctrl: ctrl}
	mock.recorder = &MockRelationshipTupleReaderMockRecorder{mock}
	return mock
}

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

// Read mocks base method.
func (m *MockRelationshipTupleReader) Read(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockRelationshipTupleReaderMockRecorder) Read(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockRelationshipTupleReader)(nil).Read), ctx, store, filter, options)
}

// ReadPage mocks base method.
func (m *MockRelationshipTupleReader) ReadPage(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadPageOptions) ([]*openfgav1.Tuple, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadPage", ctx, store, filter, options)
	ret0, _ := ret[0].([]*openfgav1.Tuple)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadPage indicates an expected call of ReadPage.
func (mr *MockRelationshipTupleReaderMockRecorder) ReadPage(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPage", reflect.TypeOf((*MockRelationshipTupleReader)(nil).ReadPage), ctx, store, filter, options)
}

// ReadStartingWithUser mocks base method.
func (m *MockRelationshipTupleReader) ReadStartingWithUser(ctx context.Context, store string, filter storage.ReadStartingWithUserFilter, options storage.ReadStartingWithUserOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStartingWithUser", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadStartingWithUser indicates an expected call of ReadStartingWithUser.
func (mr *MockRelationshipTupleReaderMockRecorder) ReadStartingWithUser(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStartingWithUser", reflect.TypeOf((*MockRelationshipTupleReader)(nil).ReadStartingWithUser), ctx, store, filter, options)
}

// ReadUserTuple mocks base method.
func (m *MockRelationshipTupleReader) ReadUserTuple(ctx context.Context, store string, filter storage.ReadUserTupleFilter, options storage.ReadUserTupleOptions) (*openfgav1.Tuple, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUserTuple", ctx, store, filter, options)
	ret0, _ := ret[0].(*openfgav1.Tuple)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUserTuple indicates an expected call of ReadUserTuple.
func (mr *MockRelationshipTupleReaderMockRecorder) ReadUserTuple(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUserTuple", reflect.TypeOf((*MockRelationshipTupleReader)(nil).ReadUserTuple), ctx, store, filter, options)
}

// ReadUsersetTuples mocks base method.
func (m *MockRelationshipTupleReader) ReadUsersetTuples(ctx context.Context, store string, filter storage.ReadUsersetTuplesFilter, options storage.ReadUsersetTuplesOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUsersetTuples", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUsersetTuples indicates an expected call of ReadUsersetTuples.
func (mr *MockRelationshipTupleReaderMockRecorder) ReadUsersetTuples(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUsersetTuples", reflect.TypeOf((*MockRelationshipTupleReader)(nil).ReadUsersetTuples), ctx, store, filter, options)
}

// MockRelationshipTupleWriter is a mock of RelationshipTupleWriter interface.
type MockRelationshipTupleWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRelationshipTupleWriterMockRecorder
	isgomock struct{}
}

// MockRelationshipTupleWriterMockRecorder is the mock recorder for MockRelationshipTupleWriter.
type MockRelationshipTupleWriterMockRecorder struct {
	mock *MockRelationshipTupleWriter
}

// NewMockRelationshipTupleWriter creates a new mock instance.
func NewMockRelationshipTupleWriter(ctrl *gomock.Controller) *MockRelationshipTupleWriter {
	mock := &MockRelationshipTupleWriter{ctrl: ctrl}
	mock.recorder = &MockRelationshipTupleWriterMockRecorder{mock}
	return mock
}

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

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

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

// Write mocks base method.
func (m *MockRelationshipTupleWriter) Write(ctx context.Context, store string, d storage.Deletes, w storage.Writes, opts ...storage.TupleWriteOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, store, d, w}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockAuthorizationModelReadBackend is a mock of AuthorizationModelReadBackend interface.
type MockAuthorizationModelReadBackend struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationModelReadBackendMockRecorder
	isgomock struct{}
}

// MockAuthorizationModelReadBackendMockRecorder is the mock recorder for MockAuthorizationModelReadBackend.
type MockAuthorizationModelReadBackendMockRecorder struct {
	mock *MockAuthorizationModelReadBackend
}

// NewMockAuthorizationModelReadBackend creates a new mock instance.
func NewMockAuthorizationModelReadBackend(ctrl *gomock.Controller) *MockAuthorizationModelReadBackend {
	mock := &MockAuthorizationModelReadBackend{ctrl: ctrl}
	mock.recorder = &MockAuthorizationModelReadBackendMockRecorder{mock}
	return mock
}

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

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

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

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

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

// ReadAuthorizationModels mocks base method.
func (m *MockAuthorizationModelReadBackend) ReadAuthorizationModels(ctx context.Context, store string, options storage.ReadAuthorizationModelsOptions) ([]*openfgav1.AuthorizationModel, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadAuthorizationModels", ctx, store, options)
	ret0, _ := ret[0].([]*openfgav1.AuthorizationModel)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadAuthorizationModels indicates an expected call of ReadAuthorizationModels.
func (mr *MockAuthorizationModelReadBackendMockRecorder) ReadAuthorizationModels(ctx, store, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAuthorizationModels", reflect.TypeOf((*MockAuthorizationModelReadBackend)(nil).ReadAuthorizationModels), ctx, store, options)
}

// MockTypeDefinitionWriteBackend is a mock of TypeDefinitionWriteBackend interface.
type MockTypeDefinitionWriteBackend struct {
	ctrl     *gomock.Controller
	recorder *MockTypeDefinitionWriteBackendMockRecorder
	isgomock struct{}
}

// MockTypeDefinitionWriteBackendMockRecorder is the mock recorder for MockTypeDefinitionWriteBackend.
type MockTypeDefinitionWriteBackendMockRecorder struct {
	mock *MockTypeDefinitionWriteBackend
}

// NewMockTypeDefinitionWriteBackend creates a new mock instance.
func NewMockTypeDefinitionWriteBackend(ctrl *gomock.Controller) *MockTypeDefinitionWriteBackend {
	mock := &MockTypeDefinitionWriteBackend{ctrl: ctrl}
	mock.recorder = &MockTypeDefinitionWriteBackendMockRecorder{mock}
	return mock
}

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

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

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

// WriteAuthorizationModel mocks base method.
func (m *MockTypeDefinitionWriteBackend) WriteAuthorizationModel(ctx context.Context, store string, model *openfgav1.AuthorizationModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAuthorizationModel", ctx, store, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAuthorizationModel indicates an expected call of WriteAuthorizationModel.
func (mr *MockTypeDefinitionWriteBackendMockRecorder) WriteAuthorizationModel(ctx, store, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAuthorizationModel", reflect.TypeOf((*MockTypeDefinitionWriteBackend)(nil).WriteAuthorizationModel), ctx, store, model)
}

// MockAuthorizationModelBackend is a mock of AuthorizationModelBackend interface.
type MockAuthorizationModelBackend struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationModelBackendMockRecorder
	isgomock struct{}
}

// MockAuthorizationModelBackendMockRecorder is the mock recorder for MockAuthorizationModelBackend.
type MockAuthorizationModelBackendMockRecorder struct {
	mock *MockAuthorizationModelBackend
}

// NewMockAuthorizationModelBackend creates a new mock instance.
func NewMockAuthorizationModelBackend(ctrl *gomock.Controller) *MockAuthorizationModelBackend {
	mock := &MockAuthorizationModelBackend{ctrl: ctrl}
	mock.recorder = &MockAuthorizationModelBackendMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// ReadAuthorizationModels mocks base method.
func (m *MockAuthorizationModelBackend) ReadAuthorizationModels(ctx context.Context, store string, options storage.ReadAuthorizationModelsOptions) ([]*openfgav1.AuthorizationModel, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadAuthorizationModels", ctx, store, options)
	ret0, _ := ret[0].([]*openfgav1.AuthorizationModel)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadAuthorizationModels indicates an expected call of ReadAuthorizationModels.
func (mr *MockAuthorizationModelBackendMockRecorder) ReadAuthorizationModels(ctx, store, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAuthorizationModels", reflect.TypeOf((*MockAuthorizationModelBackend)(nil).ReadAuthorizationModels), ctx, store, options)
}

// WriteAuthorizationModel mocks base method.
func (m *MockAuthorizationModelBackend) WriteAuthorizationModel(ctx context.Context, store string, model *openfgav1.AuthorizationModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAuthorizationModel", ctx, store, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAuthorizationModel indicates an expected call of WriteAuthorizationModel.
func (mr *MockAuthorizationModelBackendMockRecorder) WriteAuthorizationModel(ctx, store, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAuthorizationModel", reflect.TypeOf((*MockAuthorizationModelBackend)(nil).WriteAuthorizationModel), ctx, store, model)
}

// MockStoresBackend is a mock of StoresBackend interface.
type MockStoresBackend struct {
	ctrl     *gomock.Controller
	recorder *MockStoresBackendMockRecorder
	isgomock struct{}
}

// MockStoresBackendMockRecorder is the mock recorder for MockStoresBackend.
type MockStoresBackendMockRecorder struct {
	mock *MockStoresBackend
}

// NewMockStoresBackend creates a new mock instance.
func NewMockStoresBackend(ctrl *gomock.Controller) *MockStoresBackend {
	mock := &MockStoresBackend{ctrl: ctrl}
	mock.recorder = &MockStoresBackendMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// ListStores mocks base method.
func (m *MockStoresBackend) ListStores(ctx context.Context, options storage.ListStoresOptions) ([]*openfgav1.Store, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStores", ctx, options)
	ret0, _ := ret[0].([]*openfgav1.Store)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MockAssertionsBackend is a mock of AssertionsBackend interface.
type MockAssertionsBackend struct {
	ctrl     *gomock.Controller
	recorder *MockAssertionsBackendMockRecorder
	isgomock struct{}
}

// MockAssertionsBackendMockRecorder is the mock recorder for MockAssertionsBackend.
type MockAssertionsBackendMockRecorder struct {
	mock *MockAssertionsBackend
}

// NewMockAssertionsBackend creates a new mock instance.
func NewMockAssertionsBackend(ctrl *gomock.Controller) *MockAssertionsBackend {
	mock := &MockAssertionsBackend{ctrl: ctrl}
	mock.recorder = &MockAssertionsBackendMockRecorder{mock}
	return mock
}

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

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

// ReadAssertions indicates an expected call of ReadAssertions.
func (mr *MockAssertionsBackendMockRecorder) ReadAssertions(ctx, store, modelID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAssertions", reflect.TypeOf((*MockAssertionsBackend)(nil).ReadAssertions), ctx, store, modelID)
}

// WriteAssertions mocks base method.
func (m *MockAssertionsBackend) WriteAssertions(ctx context.Context, store, modelID string, assertions []*openfgav1.Assertion) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAssertions", ctx, store, modelID, assertions)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAssertions indicates an expected call of WriteAssertions.
func (mr *MockAssertionsBackendMockRecorder) WriteAssertions(ctx, store, modelID, assertions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAssertions", reflect.TypeOf((*MockAssertionsBackend)(nil).WriteAssertions), ctx, store, modelID, assertions)
}

// MockChangelogBackend is a mock of ChangelogBackend interface.
type MockChangelogBackend struct {
	ctrl     *gomock.Controller
	recorder *MockChangelogBackendMockRecorder
	isgomock struct{}
}

// MockChangelogBackendMockRecorder is the mock recorder for MockChangelogBackend.
type MockChangelogBackendMockRecorder struct {
	mock *MockChangelogBackend
}

// NewMockChangelogBackend creates a new mock instance.
func NewMockChangelogBackend(ctrl *gomock.Controller) *MockChangelogBackend {
	mock := &MockChangelogBackend{ctrl: ctrl}
	mock.recorder = &MockChangelogBackendMockRecorder{mock}
	return mock
}

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

// ReadChanges mocks base method.
func (m *MockChangelogBackend) ReadChanges(ctx context.Context, store string, filter storage.ReadChangesFilter, options storage.ReadChangesOptions) ([]*openfgav1.TupleChange, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadChanges", ctx, store, filter, options)
	ret0, _ := ret[0].([]*openfgav1.TupleChange)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadChanges indicates an expected call of ReadChanges.
func (mr *MockChangelogBackendMockRecorder) ReadChanges(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadChanges", reflect.TypeOf((*MockChangelogBackend)(nil).ReadChanges), ctx, store, filter, options)
}

// MockOpenFGADatastore is a mock of OpenFGADatastore interface.
type MockOpenFGADatastore struct {
	ctrl     *gomock.Controller
	recorder *MockOpenFGADatastoreMockRecorder
	isgomock struct{}
}

// MockOpenFGADatastoreMockRecorder is the mock recorder for MockOpenFGADatastore.
type MockOpenFGADatastoreMockRecorder struct {
	mock *MockOpenFGADatastore
}

// NewMockOpenFGADatastore creates a new mock instance.
func NewMockOpenFGADatastore(ctrl *gomock.Controller) *MockOpenFGADatastore {
	mock := &MockOpenFGADatastore{ctrl: ctrl}
	mock.recorder = &MockOpenFGADatastoreMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListStores mocks base method.
func (m *MockOpenFGADatastore) ListStores(ctx context.Context, options storage.ListStoresOptions) ([]*openfgav1.Store, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStores", ctx, options)
	ret0, _ := ret[0].([]*openfgav1.Store)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

// Read mocks base method.
func (m *MockOpenFGADatastore) Read(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockOpenFGADatastoreMockRecorder) Read(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockOpenFGADatastore)(nil).Read), ctx, store, filter, options)
}

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

// ReadAssertions indicates an expected call of ReadAssertions.
func (mr *MockOpenFGADatastoreMockRecorder) ReadAssertions(ctx, store, modelID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAssertions", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadAssertions), ctx, store, modelID)
}

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

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

// ReadAuthorizationModels mocks base method.
func (m *MockOpenFGADatastore) ReadAuthorizationModels(ctx context.Context, store string, options storage.ReadAuthorizationModelsOptions) ([]*openfgav1.AuthorizationModel, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadAuthorizationModels", ctx, store, options)
	ret0, _ := ret[0].([]*openfgav1.AuthorizationModel)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadAuthorizationModels indicates an expected call of ReadAuthorizationModels.
func (mr *MockOpenFGADatastoreMockRecorder) ReadAuthorizationModels(ctx, store, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAuthorizationModels", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadAuthorizationModels), ctx, store, options)
}

// ReadChanges mocks base method.
func (m *MockOpenFGADatastore) ReadChanges(ctx context.Context, store string, filter storage.ReadChangesFilter, options storage.ReadChangesOptions) ([]*openfgav1.TupleChange, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadChanges", ctx, store, filter, options)
	ret0, _ := ret[0].([]*openfgav1.TupleChange)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadChanges indicates an expected call of ReadChanges.
func (mr *MockOpenFGADatastoreMockRecorder) ReadChanges(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadChanges", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadChanges), ctx, store, filter, options)
}

// ReadPage mocks base method.
func (m *MockOpenFGADatastore) ReadPage(ctx context.Context, store string, filter storage.ReadFilter, options storage.ReadPageOptions) ([]*openfgav1.Tuple, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadPage", ctx, store, filter, options)
	ret0, _ := ret[0].([]*openfgav1.Tuple)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReadPage indicates an expected call of ReadPage.
func (mr *MockOpenFGADatastoreMockRecorder) ReadPage(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPage", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadPage), ctx, store, filter, options)
}

// ReadStartingWithUser mocks base method.
func (m *MockOpenFGADatastore) ReadStartingWithUser(ctx context.Context, store string, filter storage.ReadStartingWithUserFilter, options storage.ReadStartingWithUserOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadStartingWithUser", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadStartingWithUser indicates an expected call of ReadStartingWithUser.
func (mr *MockOpenFGADatastoreMockRecorder) ReadStartingWithUser(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadStartingWithUser", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadStartingWithUser), ctx, store, filter, options)
}

// ReadUserTuple mocks base method.
func (m *MockOpenFGADatastore) ReadUserTuple(ctx context.Context, store string, filter storage.ReadUserTupleFilter, options storage.ReadUserTupleOptions) (*openfgav1.Tuple, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUserTuple", ctx, store, filter, options)
	ret0, _ := ret[0].(*openfgav1.Tuple)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUserTuple indicates an expected call of ReadUserTuple.
func (mr *MockOpenFGADatastoreMockRecorder) ReadUserTuple(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUserTuple", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadUserTuple), ctx, store, filter, options)
}

// ReadUsersetTuples mocks base method.
func (m *MockOpenFGADatastore) ReadUsersetTuples(ctx context.Context, store string, filter storage.ReadUsersetTuplesFilter, options storage.ReadUsersetTuplesOptions) (storage.TupleIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadUsersetTuples", ctx, store, filter, options)
	ret0, _ := ret[0].(storage.TupleIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadUsersetTuples indicates an expected call of ReadUsersetTuples.
func (mr *MockOpenFGADatastoreMockRecorder) ReadUsersetTuples(ctx, store, filter, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadUsersetTuples", reflect.TypeOf((*MockOpenFGADatastore)(nil).ReadUsersetTuples), ctx, store, filter, options)
}

// Write mocks base method.
func (m *MockOpenFGADatastore) Write(ctx context.Context, store string, d storage.Deletes, w storage.Writes, opts ...storage.TupleWriteOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, store, d, w}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WriteAssertions mocks base method.
func (m *MockOpenFGADatastore) WriteAssertions(ctx context.Context, store, modelID string, assertions []*openfgav1.Assertion) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAssertions", ctx, store, modelID, assertions)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAssertions indicates an expected call of WriteAssertions.
func (mr *MockOpenFGADatastoreMockRecorder) WriteAssertions(ctx, store, modelID, assertions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAssertions", reflect.TypeOf((*MockOpenFGADatastore)(nil).WriteAssertions), ctx, store, modelID, assertions)
}

// WriteAuthorizationModel mocks base method.
func (m *MockOpenFGADatastore) WriteAuthorizationModel(ctx context.Context, store string, model *openfgav1.AuthorizationModel) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAuthorizationModel", ctx, store, model)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteAuthorizationModel indicates an expected call of WriteAuthorizationModel.
func (mr *MockOpenFGADatastoreMockRecorder) WriteAuthorizationModel(ctx, store, model any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAuthorizationModel", reflect.TypeOf((*MockOpenFGADatastore)(nil).WriteAuthorizationModel), ctx, store, model)
}
