galaxy-game/gamemaster/internal/api/internalhttp/handlers/mocks/mock_services.go

// Code generated by MockGen. DO NOT EDIT.
// Source: galaxy/gamemaster/internal/api/internalhttp/handlers (interfaces: RegisterRuntimeService,ForceNextTurnService,StopRuntimeService,PatchRuntimeService,BanishRaceService,LivenessService,CommandExecuteService,OrderPutService,ReportGetService,MembershipInvalidator,EngineVersionService,RuntimeRecordsReader)
//
// Generated by this command:
//
//	mockgen -destination=./mocks/mock_services.go -package=mocks galaxy/gamemaster/internal/api/internalhttp/handlers RegisterRuntimeService,ForceNextTurnService,StopRuntimeService,PatchRuntimeService,BanishRaceService,LivenessService,CommandExecuteService,OrderPutService,ReportGetService,MembershipInvalidator,EngineVersionService,RuntimeRecordsReader
//

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

import (
	context "context"
	engineversion "galaxy/gamemaster/internal/domain/engineversion"
	runtime "galaxy/gamemaster/internal/domain/runtime"
	adminbanish "galaxy/gamemaster/internal/service/adminbanish"
	adminforce "galaxy/gamemaster/internal/service/adminforce"
	adminpatch "galaxy/gamemaster/internal/service/adminpatch"
	adminstop "galaxy/gamemaster/internal/service/adminstop"
	commandexecute "galaxy/gamemaster/internal/service/commandexecute"
	engineversion0 "galaxy/gamemaster/internal/service/engineversion"
	livenessreply "galaxy/gamemaster/internal/service/livenessreply"
	orderput "galaxy/gamemaster/internal/service/orderput"
	registerruntime "galaxy/gamemaster/internal/service/registerruntime"
	reportget "galaxy/gamemaster/internal/service/reportget"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockRegisterRuntimeService is a mock of RegisterRuntimeService interface.
type MockRegisterRuntimeService struct {
	ctrl     *gomock.Controller
	recorder *MockRegisterRuntimeServiceMockRecorder
	isgomock struct{}
}

// MockRegisterRuntimeServiceMockRecorder is the mock recorder for MockRegisterRuntimeService.
type MockRegisterRuntimeServiceMockRecorder struct {
	mock *MockRegisterRuntimeService
}

// NewMockRegisterRuntimeService creates a new mock instance.
func NewMockRegisterRuntimeService(ctrl *gomock.Controller) *MockRegisterRuntimeService {
	mock := &MockRegisterRuntimeService{ctrl: ctrl}
	mock.recorder = &MockRegisterRuntimeServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockRegisterRuntimeService) Handle(ctx context.Context, in registerruntime.Input) (registerruntime.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(registerruntime.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockForceNextTurnService is a mock of ForceNextTurnService interface.
type MockForceNextTurnService struct {
	ctrl     *gomock.Controller
	recorder *MockForceNextTurnServiceMockRecorder
	isgomock struct{}
}

// MockForceNextTurnServiceMockRecorder is the mock recorder for MockForceNextTurnService.
type MockForceNextTurnServiceMockRecorder struct {
	mock *MockForceNextTurnService
}

// NewMockForceNextTurnService creates a new mock instance.
func NewMockForceNextTurnService(ctrl *gomock.Controller) *MockForceNextTurnService {
	mock := &MockForceNextTurnService{ctrl: ctrl}
	mock.recorder = &MockForceNextTurnServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockForceNextTurnService) Handle(ctx context.Context, in adminforce.Input) (adminforce.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(adminforce.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockStopRuntimeService is a mock of StopRuntimeService interface.
type MockStopRuntimeService struct {
	ctrl     *gomock.Controller
	recorder *MockStopRuntimeServiceMockRecorder
	isgomock struct{}
}

// MockStopRuntimeServiceMockRecorder is the mock recorder for MockStopRuntimeService.
type MockStopRuntimeServiceMockRecorder struct {
	mock *MockStopRuntimeService
}

// NewMockStopRuntimeService creates a new mock instance.
func NewMockStopRuntimeService(ctrl *gomock.Controller) *MockStopRuntimeService {
	mock := &MockStopRuntimeService{ctrl: ctrl}
	mock.recorder = &MockStopRuntimeServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockStopRuntimeService) Handle(ctx context.Context, in adminstop.Input) (adminstop.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(adminstop.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockPatchRuntimeService is a mock of PatchRuntimeService interface.
type MockPatchRuntimeService struct {
	ctrl     *gomock.Controller
	recorder *MockPatchRuntimeServiceMockRecorder
	isgomock struct{}
}

// MockPatchRuntimeServiceMockRecorder is the mock recorder for MockPatchRuntimeService.
type MockPatchRuntimeServiceMockRecorder struct {
	mock *MockPatchRuntimeService
}

// NewMockPatchRuntimeService creates a new mock instance.
func NewMockPatchRuntimeService(ctrl *gomock.Controller) *MockPatchRuntimeService {
	mock := &MockPatchRuntimeService{ctrl: ctrl}
	mock.recorder = &MockPatchRuntimeServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockPatchRuntimeService) Handle(ctx context.Context, in adminpatch.Input) (adminpatch.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(adminpatch.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockBanishRaceService is a mock of BanishRaceService interface.
type MockBanishRaceService struct {
	ctrl     *gomock.Controller
	recorder *MockBanishRaceServiceMockRecorder
	isgomock struct{}
}

// MockBanishRaceServiceMockRecorder is the mock recorder for MockBanishRaceService.
type MockBanishRaceServiceMockRecorder struct {
	mock *MockBanishRaceService
}

// NewMockBanishRaceService creates a new mock instance.
func NewMockBanishRaceService(ctrl *gomock.Controller) *MockBanishRaceService {
	mock := &MockBanishRaceService{ctrl: ctrl}
	mock.recorder = &MockBanishRaceServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockBanishRaceService) Handle(ctx context.Context, in adminbanish.Input) (adminbanish.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(adminbanish.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLivenessService is a mock of LivenessService interface.
type MockLivenessService struct {
	ctrl     *gomock.Controller
	recorder *MockLivenessServiceMockRecorder
	isgomock struct{}
}

// MockLivenessServiceMockRecorder is the mock recorder for MockLivenessService.
type MockLivenessServiceMockRecorder struct {
	mock *MockLivenessService
}

// NewMockLivenessService creates a new mock instance.
func NewMockLivenessService(ctrl *gomock.Controller) *MockLivenessService {
	mock := &MockLivenessService{ctrl: ctrl}
	mock.recorder = &MockLivenessServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockLivenessService) Handle(ctx context.Context, in livenessreply.Input) (livenessreply.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(livenessreply.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockCommandExecuteService is a mock of CommandExecuteService interface.
type MockCommandExecuteService struct {
	ctrl     *gomock.Controller
	recorder *MockCommandExecuteServiceMockRecorder
	isgomock struct{}
}

// MockCommandExecuteServiceMockRecorder is the mock recorder for MockCommandExecuteService.
type MockCommandExecuteServiceMockRecorder struct {
	mock *MockCommandExecuteService
}

// NewMockCommandExecuteService creates a new mock instance.
func NewMockCommandExecuteService(ctrl *gomock.Controller) *MockCommandExecuteService {
	mock := &MockCommandExecuteService{ctrl: ctrl}
	mock.recorder = &MockCommandExecuteServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockCommandExecuteService) Handle(ctx context.Context, in commandexecute.Input) (commandexecute.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(commandexecute.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockOrderPutService is a mock of OrderPutService interface.
type MockOrderPutService struct {
	ctrl     *gomock.Controller
	recorder *MockOrderPutServiceMockRecorder
	isgomock struct{}
}

// MockOrderPutServiceMockRecorder is the mock recorder for MockOrderPutService.
type MockOrderPutServiceMockRecorder struct {
	mock *MockOrderPutService
}

// NewMockOrderPutService creates a new mock instance.
func NewMockOrderPutService(ctrl *gomock.Controller) *MockOrderPutService {
	mock := &MockOrderPutService{ctrl: ctrl}
	mock.recorder = &MockOrderPutServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockOrderPutService) Handle(ctx context.Context, in orderput.Input) (orderput.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(orderput.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockReportGetService is a mock of ReportGetService interface.
type MockReportGetService struct {
	ctrl     *gomock.Controller
	recorder *MockReportGetServiceMockRecorder
	isgomock struct{}
}

// MockReportGetServiceMockRecorder is the mock recorder for MockReportGetService.
type MockReportGetServiceMockRecorder struct {
	mock *MockReportGetService
}

// NewMockReportGetService creates a new mock instance.
func NewMockReportGetService(ctrl *gomock.Controller) *MockReportGetService {
	mock := &MockReportGetService{ctrl: ctrl}
	mock.recorder = &MockReportGetServiceMockRecorder{mock}
	return mock
}

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

// Handle mocks base method.
func (m *MockReportGetService) Handle(ctx context.Context, in reportget.Input) (reportget.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, in)
	ret0, _ := ret[0].(reportget.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockMembershipInvalidator is a mock of MembershipInvalidator interface.
type MockMembershipInvalidator struct {
	ctrl     *gomock.Controller
	recorder *MockMembershipInvalidatorMockRecorder
	isgomock struct{}
}

// MockMembershipInvalidatorMockRecorder is the mock recorder for MockMembershipInvalidator.
type MockMembershipInvalidatorMockRecorder struct {
	mock *MockMembershipInvalidator
}

// NewMockMembershipInvalidator creates a new mock instance.
func NewMockMembershipInvalidator(ctrl *gomock.Controller) *MockMembershipInvalidator {
	mock := &MockMembershipInvalidator{ctrl: ctrl}
	mock.recorder = &MockMembershipInvalidatorMockRecorder{mock}
	return mock
}

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

// Invalidate mocks base method.
func (m *MockMembershipInvalidator) Invalidate(gameID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Invalidate", gameID)
}

// Invalidate indicates an expected call of Invalidate.
func (mr *MockMembershipInvalidatorMockRecorder) Invalidate(gameID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invalidate", reflect.TypeOf((*MockMembershipInvalidator)(nil).Invalidate), gameID)
}

// MockEngineVersionService is a mock of EngineVersionService interface.
type MockEngineVersionService struct {
	ctrl     *gomock.Controller
	recorder *MockEngineVersionServiceMockRecorder
	isgomock struct{}
}

// MockEngineVersionServiceMockRecorder is the mock recorder for MockEngineVersionService.
type MockEngineVersionServiceMockRecorder struct {
	mock *MockEngineVersionService
}

// NewMockEngineVersionService creates a new mock instance.
func NewMockEngineVersionService(ctrl *gomock.Controller) *MockEngineVersionService {
	mock := &MockEngineVersionService{ctrl: ctrl}
	mock.recorder = &MockEngineVersionServiceMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockEngineVersionService) Create(ctx context.Context, in engineversion0.CreateInput) (engineversion.EngineVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, in)
	ret0, _ := ret[0].(engineversion.EngineVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// List mocks base method.
func (m *MockEngineVersionService) List(ctx context.Context, statusFilter *engineversion.Status) ([]engineversion.EngineVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, statusFilter)
	ret0, _ := ret[0].([]engineversion.EngineVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Update mocks base method.
func (m *MockEngineVersionService) Update(ctx context.Context, in engineversion0.UpdateInput) (engineversion.EngineVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, in)
	ret0, _ := ret[0].(engineversion.EngineVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockRuntimeRecordsReader is a mock of RuntimeRecordsReader interface.
type MockRuntimeRecordsReader struct {
	ctrl     *gomock.Controller
	recorder *MockRuntimeRecordsReaderMockRecorder
	isgomock struct{}
}

// MockRuntimeRecordsReaderMockRecorder is the mock recorder for MockRuntimeRecordsReader.
type MockRuntimeRecordsReaderMockRecorder struct {
	mock *MockRuntimeRecordsReader
}

// NewMockRuntimeRecordsReader creates a new mock instance.
func NewMockRuntimeRecordsReader(ctrl *gomock.Controller) *MockRuntimeRecordsReader {
	mock := &MockRuntimeRecordsReader{ctrl: ctrl}
	mock.recorder = &MockRuntimeRecordsReaderMockRecorder{mock}
	return mock
}

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

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

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

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

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

// ListByStatus mocks base method.
func (m *MockRuntimeRecordsReader) ListByStatus(ctx context.Context, status runtime.Status) ([]runtime.RuntimeRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByStatus", ctx, status)
	ret0, _ := ret[0].([]runtime.RuntimeRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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