zitadel/backend/v3/domain/mock/administrator.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: AdministratorRepository)
//
// Generated by this command:
//
//	mockgen -typed -package domainmock -destination ./mock/administrator.mock.go . AdministratorRepository
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	domain "github.com/zitadel/zitadel/backend/v3/domain"
	database "github.com/zitadel/zitadel/backend/v3/storage/database"
	gomock "go.uber.org/mock/gomock"
)

// MockAdministratorRepository is a mock of AdministratorRepository interface.
type MockAdministratorRepository struct {
	ctrl     *gomock.Controller
	recorder *MockAdministratorRepositoryMockRecorder
	isgomock struct{}
}

// MockAdministratorRepositoryMockRecorder is the mock recorder for MockAdministratorRepository.
type MockAdministratorRepositoryMockRecorder struct {
	mock *MockAdministratorRepository
}

// NewMockAdministratorRepository creates a new mock instance.
func NewMockAdministratorRepository(ctrl *gomock.Controller) *MockAdministratorRepository {
	mock := &MockAdministratorRepository{ctrl: ctrl}
	mock.recorder = &MockAdministratorRepositoryMockRecorder{mock}
	return mock
}

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

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

// AddRole indicates an expected call of AddRole.
func (mr *MockAdministratorRepositoryMockRecorder) AddRole(role any) *MockAdministratorRepositoryAddRoleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRole", reflect.TypeOf((*MockAdministratorRepository)(nil).AddRole), role)
	return &MockAdministratorRepositoryAddRoleCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryAddRoleCall) Return(arg0 database.Change) *MockAdministratorRepositoryAddRoleCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryAddRoleCall) Do(f func(string) database.Change) *MockAdministratorRepositoryAddRoleCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryAddRoleCall) DoAndReturn(f func(string) database.Change) *MockAdministratorRepositoryAddRoleCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Create mocks base method.
func (m *MockAdministratorRepository) Create(ctx context.Context, client database.QueryExecutor, administrator *domain.Administrator) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, client, administrator)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockAdministratorRepositoryMockRecorder) Create(ctx, client, administrator any) *MockAdministratorRepositoryCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAdministratorRepository)(nil).Create), ctx, client, administrator)
	return &MockAdministratorRepositoryCreateCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.Administrator) error) *MockAdministratorRepositoryCreateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Administrator) error) *MockAdministratorRepositoryCreateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatedAtColumn mocks base method.
func (m *MockAdministratorRepository) CreatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockAdministratorRepositoryMockRecorder) CreatedAtColumn() *MockAdministratorRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).CreatedAtColumn))
	return &MockAdministratorRepositoryCreatedAtColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Delete mocks base method.
func (m *MockAdministratorRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, client, condition)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockAdministratorRepositoryMockRecorder) Delete(ctx, client, condition any) *MockAdministratorRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAdministratorRepository)(nil).Delete), ctx, client, condition)
	return &MockAdministratorRepositoryDeleteCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockAdministratorRepositoryDeleteCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockAdministratorRepositoryDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockAdministratorRepositoryDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockAdministratorRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Administrator, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*domain.Administrator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAdministratorRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockAdministratorRepositoryGetCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAdministratorRepository)(nil).Get), varargs...)
	return &MockAdministratorRepositoryGetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryGetCall) Return(arg0 *domain.Administrator, arg1 error) *MockAdministratorRepositoryGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Administrator, error)) *MockAdministratorRepositoryGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Administrator, error)) *MockAdministratorRepositoryGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IDColumn mocks base method.
func (m *MockAdministratorRepository) IDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// IDColumn indicates an expected call of IDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) IDColumn() *MockAdministratorRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).IDColumn))
	return &MockAdministratorRepositoryIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) IDCondition(administratorID any) *MockAdministratorRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).IDCondition), administratorID)
	return &MockAdministratorRepositoryIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceAdministratorCondition mocks base method.
func (m *MockAdministratorRepository) InstanceAdministratorCondition(instanceID, userID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceAdministratorCondition", instanceID, userID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// InstanceAdministratorCondition indicates an expected call of InstanceAdministratorCondition.
func (mr *MockAdministratorRepositoryMockRecorder) InstanceAdministratorCondition(instanceID, userID any) *MockAdministratorRepositoryInstanceAdministratorConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceAdministratorCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).InstanceAdministratorCondition), instanceID, userID)
	return &MockAdministratorRepositoryInstanceAdministratorConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryInstanceAdministratorConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryInstanceAdministratorConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryInstanceAdministratorConditionCall) Do(f func(string, string) database.Condition) *MockAdministratorRepositoryInstanceAdministratorConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryInstanceAdministratorConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockAdministratorRepositoryInstanceAdministratorConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceIDColumn mocks base method.
func (m *MockAdministratorRepository) InstanceIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) InstanceIDColumn() *MockAdministratorRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).InstanceIDColumn))
	return &MockAdministratorRepositoryInstanceIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockAdministratorRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).InstanceIDCondition), instanceID)
	return &MockAdministratorRepositoryInstanceIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryInstanceIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// List mocks base method.
func (m *MockAdministratorRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Administrator, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]*domain.Administrator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockAdministratorRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockAdministratorRepositoryListCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockAdministratorRepository)(nil).List), varargs...)
	return &MockAdministratorRepositoryListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryListCall) Return(arg0 []*domain.Administrator, arg1 error) *MockAdministratorRepositoryListCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Administrator, error)) *MockAdministratorRepositoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Administrator, error)) *MockAdministratorRepositoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OrganizationAdministratorCondition mocks base method.
func (m *MockAdministratorRepository) OrganizationAdministratorCondition(instanceID, organizationID, userID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrganizationAdministratorCondition", instanceID, organizationID, userID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// OrganizationAdministratorCondition indicates an expected call of OrganizationAdministratorCondition.
func (mr *MockAdministratorRepositoryMockRecorder) OrganizationAdministratorCondition(instanceID, organizationID, userID any) *MockAdministratorRepositoryOrganizationAdministratorConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationAdministratorCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).OrganizationAdministratorCondition), instanceID, organizationID, userID)
	return &MockAdministratorRepositoryOrganizationAdministratorConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryOrganizationAdministratorConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryOrganizationAdministratorConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryOrganizationAdministratorConditionCall) Do(f func(string, string, string) database.Condition) *MockAdministratorRepositoryOrganizationAdministratorConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryOrganizationAdministratorConditionCall) DoAndReturn(f func(string, string, string) database.Condition) *MockAdministratorRepositoryOrganizationAdministratorConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OrganizationIDColumn mocks base method.
func (m *MockAdministratorRepository) OrganizationIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrganizationIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) OrganizationIDColumn() *MockAdministratorRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).OrganizationIDColumn))
	return &MockAdministratorRepositoryOrganizationIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryOrganizationIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) OrganizationIDCondition(organizationID any) *MockAdministratorRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).OrganizationIDCondition), organizationID)
	return &MockAdministratorRepositoryOrganizationIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryOrganizationIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryOrganizationIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyColumns mocks base method.
func (m *MockAdministratorRepository) PrimaryKeyColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockAdministratorRepositoryMockRecorder) PrimaryKeyColumns() *MockAdministratorRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockAdministratorRepository)(nil).PrimaryKeyColumns))
	return &MockAdministratorRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockAdministratorRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockAdministratorRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockAdministratorRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyCondition mocks base method.
func (m *MockAdministratorRepository) PrimaryKeyCondition(instanceID, administratorID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, administratorID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockAdministratorRepositoryMockRecorder) PrimaryKeyCondition(instanceID, administratorID any) *MockAdministratorRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).PrimaryKeyCondition), instanceID, administratorID)
	return &MockAdministratorRepositoryPrimaryKeyConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockAdministratorRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockAdministratorRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ProjectAdministratorCondition mocks base method.
func (m *MockAdministratorRepository) ProjectAdministratorCondition(instanceID, projectID, userID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProjectAdministratorCondition", instanceID, projectID, userID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ProjectAdministratorCondition indicates an expected call of ProjectAdministratorCondition.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectAdministratorCondition(instanceID, projectID, userID any) *MockAdministratorRepositoryProjectAdministratorConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectAdministratorCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectAdministratorCondition), instanceID, projectID, userID)
	return &MockAdministratorRepositoryProjectAdministratorConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectAdministratorConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryProjectAdministratorConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryProjectAdministratorConditionCall) Do(f func(string, string, string) database.Condition) *MockAdministratorRepositoryProjectAdministratorConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryProjectAdministratorConditionCall) DoAndReturn(f func(string, string, string) database.Condition) *MockAdministratorRepositoryProjectAdministratorConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ProjectGrantAdministratorCondition mocks base method.
func (m *MockAdministratorRepository) ProjectGrantAdministratorCondition(instanceID, projectGrantID, userID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProjectGrantAdministratorCondition", instanceID, projectGrantID, userID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ProjectGrantAdministratorCondition indicates an expected call of ProjectGrantAdministratorCondition.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectGrantAdministratorCondition(instanceID, projectGrantID, userID any) *MockAdministratorRepositoryProjectGrantAdministratorConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectGrantAdministratorCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectGrantAdministratorCondition), instanceID, projectGrantID, userID)
	return &MockAdministratorRepositoryProjectGrantAdministratorConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectGrantAdministratorConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryProjectGrantAdministratorConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryProjectGrantAdministratorConditionCall) Do(f func(string, string, string) database.Condition) *MockAdministratorRepositoryProjectGrantAdministratorConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryProjectGrantAdministratorConditionCall) DoAndReturn(f func(string, string, string) database.Condition) *MockAdministratorRepositoryProjectGrantAdministratorConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ProjectGrantIDColumn mocks base method.
func (m *MockAdministratorRepository) ProjectGrantIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProjectGrantIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// ProjectGrantIDColumn indicates an expected call of ProjectGrantIDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectGrantIDColumn() *MockAdministratorRepositoryProjectGrantIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectGrantIDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectGrantIDColumn))
	return &MockAdministratorRepositoryProjectGrantIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectGrantIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryProjectGrantIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// ProjectGrantIDCondition indicates an expected call of ProjectGrantIDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectGrantIDCondition(projectGrantID any) *MockAdministratorRepositoryProjectGrantIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectGrantIDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectGrantIDCondition), projectGrantID)
	return &MockAdministratorRepositoryProjectGrantIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectGrantIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryProjectGrantIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryProjectGrantIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryProjectGrantIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryProjectGrantIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryProjectGrantIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ProjectIDColumn mocks base method.
func (m *MockAdministratorRepository) ProjectIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProjectIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// ProjectIDColumn indicates an expected call of ProjectIDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectIDColumn() *MockAdministratorRepositoryProjectIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectIDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectIDColumn))
	return &MockAdministratorRepositoryProjectIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryProjectIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// ProjectIDCondition indicates an expected call of ProjectIDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) ProjectIDCondition(projectID any) *MockAdministratorRepositoryProjectIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectIDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).ProjectIDCondition), projectID)
	return &MockAdministratorRepositoryProjectIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryProjectIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryProjectIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryProjectIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryProjectIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryProjectIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryProjectIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// RemoveRole indicates an expected call of RemoveRole.
func (mr *MockAdministratorRepositoryMockRecorder) RemoveRole(role any) *MockAdministratorRepositoryRemoveRoleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRole", reflect.TypeOf((*MockAdministratorRepository)(nil).RemoveRole), role)
	return &MockAdministratorRepositoryRemoveRoleCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryRemoveRoleCall) Return(arg0 database.Change) *MockAdministratorRepositoryRemoveRoleCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryRemoveRoleCall) Do(f func(string) database.Change) *MockAdministratorRepositoryRemoveRoleCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryRemoveRoleCall) DoAndReturn(f func(string) database.Change) *MockAdministratorRepositoryRemoveRoleCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RoleCondition mocks base method.
func (m *MockAdministratorRepository) RoleCondition(op database.TextOperation, role string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RoleCondition", op, role)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// RoleCondition indicates an expected call of RoleCondition.
func (mr *MockAdministratorRepositoryMockRecorder) RoleCondition(op, role any) *MockAdministratorRepositoryRoleConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).RoleCondition), op, role)
	return &MockAdministratorRepositoryRoleConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryRoleConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryRoleConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryRoleConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockAdministratorRepositoryRoleConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryRoleConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockAdministratorRepositoryRoleConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ScopeColumn mocks base method.
func (m *MockAdministratorRepository) ScopeColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScopeColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// ScopeColumn indicates an expected call of ScopeColumn.
func (mr *MockAdministratorRepositoryMockRecorder) ScopeColumn() *MockAdministratorRepositoryScopeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScopeColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).ScopeColumn))
	return &MockAdministratorRepositoryScopeColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryScopeColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryScopeColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// ScopeCondition mocks base method.
func (m *MockAdministratorRepository) ScopeCondition(scope domain.AdministratorScope) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScopeCondition", scope)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ScopeCondition indicates an expected call of ScopeCondition.
func (mr *MockAdministratorRepositoryMockRecorder) ScopeCondition(scope any) *MockAdministratorRepositoryScopeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScopeCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).ScopeCondition), scope)
	return &MockAdministratorRepositoryScopeConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryScopeConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryScopeConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryScopeConditionCall) Do(f func(domain.AdministratorScope) database.Condition) *MockAdministratorRepositoryScopeConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryScopeConditionCall) DoAndReturn(f func(domain.AdministratorScope) database.Condition) *MockAdministratorRepositoryScopeConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetRoles indicates an expected call of SetRoles.
func (mr *MockAdministratorRepositoryMockRecorder) SetRoles(roles any) *MockAdministratorRepositorySetRolesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRoles", reflect.TypeOf((*MockAdministratorRepository)(nil).SetRoles), roles)
	return &MockAdministratorRepositorySetRolesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositorySetRolesCall) Return(arg0 database.Change) *MockAdministratorRepositorySetRolesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositorySetRolesCall) Do(f func([]string) database.Change) *MockAdministratorRepositorySetRolesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositorySetRolesCall) DoAndReturn(f func([]string) database.Change) *MockAdministratorRepositorySetRolesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetUpdatedAt mocks base method.
func (m *MockAdministratorRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockAdministratorRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockAdministratorRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockAdministratorRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockAdministratorRepositorySetUpdatedAtCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockAdministratorRepositorySetUpdatedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockAdministratorRepositorySetUpdatedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockAdministratorRepositorySetUpdatedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Update mocks base method.
func (m *MockAdministratorRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, condition}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockAdministratorRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockAdministratorRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockAdministratorRepository)(nil).Update), varargs...)
	return &MockAdministratorRepositoryUpdateCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockAdministratorRepositoryUpdateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockAdministratorRepositoryUpdateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockAdministratorRepositoryUpdateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedAtColumn mocks base method.
func (m *MockAdministratorRepository) UpdatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UpdatedAtColumn indicates an expected call of UpdatedAtColumn.
func (mr *MockAdministratorRepositoryMockRecorder) UpdatedAtColumn() *MockAdministratorRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).UpdatedAtColumn))
	return &MockAdministratorRepositoryUpdatedAtColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// UserIDColumn mocks base method.
func (m *MockAdministratorRepository) UserIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UserIDColumn indicates an expected call of UserIDColumn.
func (mr *MockAdministratorRepositoryMockRecorder) UserIDColumn() *MockAdministratorRepositoryUserIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockAdministratorRepository)(nil).UserIDColumn))
	return &MockAdministratorRepositoryUserIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryUserIDColumnCall) Return(arg0 database.Column) *MockAdministratorRepositoryUserIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// UserIDCondition indicates an expected call of UserIDCondition.
func (mr *MockAdministratorRepositoryMockRecorder) UserIDCondition(userID any) *MockAdministratorRepositoryUserIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockAdministratorRepository)(nil).UserIDCondition), userID)
	return &MockAdministratorRepositoryUserIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockAdministratorRepositoryUserIDConditionCall) Return(arg0 database.Condition) *MockAdministratorRepositoryUserIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockAdministratorRepositoryUserIDConditionCall) Do(f func(string) database.Condition) *MockAdministratorRepositoryUserIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAdministratorRepositoryUserIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockAdministratorRepositoryUserIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}