// Code generated by MockGen. DO NOT EDIT.
// Source: event/manager.go

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

import (
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
	time "time"
)

// MockManager is a mock of Manager interface
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

// GetLogger mocks base method
func (m *MockManager) GetLogger(eventID string) Logger {
	ret := m.ctrl.Call(m, "GetLogger", eventID)
	ret0, _ := ret[0].(Logger)
	return ret0
}

// GetLogger indicates an expected call of GetLogger
func (mr *MockManagerMockRecorder) GetLogger(eventID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogger", reflect.TypeOf((*MockManager)(nil).GetLogger), eventID)
}

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

// Start indicates an expected call of Start
func (mr *MockManagerMockRecorder) Start() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start))
}

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

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

// ReleaseLogger mocks base method
func (m *MockManager) ReleaseLogger(arg0 Logger) {
	m.ctrl.Call(m, "ReleaseLogger", arg0)
}

// ReleaseLogger indicates an expected call of ReleaseLogger
func (mr *MockManagerMockRecorder) ReleaseLogger(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLogger", reflect.TypeOf((*MockManager)(nil).ReleaseLogger), arg0)
}

// MockLogger is a mock of Logger interface
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
}

// MockLoggerMockRecorder is the mock recorder for MockLogger
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

// Info mocks base method
func (m *MockLogger) Info(arg0 string, arg1 map[string]string) {
	m.ctrl.Call(m, "Info", arg0, arg1)
}

// Info indicates an expected call of Info
func (mr *MockLoggerMockRecorder) Info(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), arg0, arg1)
}

// Error mocks base method
func (m *MockLogger) Error(arg0 string, arg1 map[string]string) {
	m.ctrl.Call(m, "Error", arg0, arg1)
}

// Error indicates an expected call of Error
func (mr *MockLoggerMockRecorder) Error(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), arg0, arg1)
}

// Debug mocks base method
func (m *MockLogger) Debug(arg0 string, arg1 map[string]string) {
	m.ctrl.Call(m, "Debug", arg0, arg1)
}

// Debug indicates an expected call of Debug
func (mr *MockLoggerMockRecorder) Debug(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), arg0, arg1)
}

// Event mocks base method
func (m *MockLogger) Event() string {
	ret := m.ctrl.Call(m, "Event")
	ret0, _ := ret[0].(string)
	return ret0
}

// Event indicates an expected call of Event
func (mr *MockLoggerMockRecorder) Event() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Event", reflect.TypeOf((*MockLogger)(nil).Event))
}

// CreateTime mocks base method
func (m *MockLogger) CreateTime() time.Time {
	ret := m.ctrl.Call(m, "CreateTime")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// CreateTime indicates an expected call of CreateTime
func (mr *MockLoggerMockRecorder) CreateTime() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTime", reflect.TypeOf((*MockLogger)(nil).CreateTime))
}

// GetChan mocks base method
func (m *MockLogger) GetChan() chan []byte {
	ret := m.ctrl.Call(m, "GetChan")
	ret0, _ := ret[0].(chan []byte)
	return ret0
}

// GetChan indicates an expected call of GetChan
func (mr *MockLoggerMockRecorder) GetChan() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChan", reflect.TypeOf((*MockLogger)(nil).GetChan))
}

// SetChan mocks base method
func (m *MockLogger) SetChan(arg0 chan []byte) {
	m.ctrl.Call(m, "SetChan", arg0)
}

// SetChan indicates an expected call of SetChan
func (mr *MockLoggerMockRecorder) SetChan(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChan", reflect.TypeOf((*MockLogger)(nil).SetChan), arg0)
}

// GetWriter mocks base method
func (m *MockLogger) GetWriter(step, level string) LoggerWriter {
	ret := m.ctrl.Call(m, "GetWriter", step, level)
	ret0, _ := ret[0].(LoggerWriter)
	return ret0
}

// GetWriter indicates an expected call of GetWriter
func (mr *MockLoggerMockRecorder) GetWriter(step, level interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriter", reflect.TypeOf((*MockLogger)(nil).GetWriter), step, level)
}

// MockLoggerWriter is a mock of LoggerWriter interface
type MockLoggerWriter struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerWriterMockRecorder
}

// MockLoggerWriterMockRecorder is the mock recorder for MockLoggerWriter
type MockLoggerWriterMockRecorder struct {
	mock *MockLoggerWriter
}

// NewMockLoggerWriter creates a new mock instance
func NewMockLoggerWriter(ctrl *gomock.Controller) *MockLoggerWriter {
	mock := &MockLoggerWriter{ctrl: ctrl}
	mock.recorder = &MockLoggerWriterMockRecorder{mock}
	return mock
}

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

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

// Write indicates an expected call of Write
func (mr *MockLoggerWriterMockRecorder) Write(p interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLoggerWriter)(nil).Write), p)
}

// SetFormat mocks base method
func (m *MockLoggerWriter) SetFormat(arg0 map[string]interface{}) {
	m.ctrl.Call(m, "SetFormat", arg0)
}

// SetFormat indicates an expected call of SetFormat
func (mr *MockLoggerWriterMockRecorder) SetFormat(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFormat", reflect.TypeOf((*MockLoggerWriter)(nil).SetFormat), arg0)
}
