// Code generated by MockGen. DO NOT EDIT.
// Source: ../interfaces/kafka_access.go
//
// Generated by this command:
//
//	mockgen -source ../interfaces/kafka_access.go -destination ../interfaces/mock/mock_kafka_access.go
//

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

import (
	context "context"
	reflect "reflect"

	kafka "github.com/segmentio/kafka-go"
	gomock "go.uber.org/mock/gomock"
)

// MockKafkaAccess is a mock of KafkaAccess interface.
type MockKafkaAccess struct {
	ctrl     *gomock.Controller
	recorder *MockKafkaAccessMockRecorder
	isgomock struct{}
}

// MockKafkaAccessMockRecorder is the mock recorder for MockKafkaAccess.
type MockKafkaAccessMockRecorder struct {
	mock *MockKafkaAccess
}

// NewMockKafkaAccess creates a new mock instance.
func NewMockKafkaAccess(ctrl *gomock.Controller) *MockKafkaAccess {
	mock := &MockKafkaAccess{ctrl: ctrl}
	mock.recorder = &MockKafkaAccessMockRecorder{mock}
	return mock
}

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

// CloseReader mocks base method.
func (m *MockKafkaAccess) CloseReader(r *kafka.Reader) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CloseReader", r)
}

// CloseReader indicates an expected call of CloseReader.
func (mr *MockKafkaAccessMockRecorder) CloseReader(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseReader", reflect.TypeOf((*MockKafkaAccess)(nil).CloseReader), r)
}

// CloseWriter mocks base method.
func (m *MockKafkaAccess) CloseWriter(w *kafka.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CloseWriter", w)
}

// CloseWriter indicates an expected call of CloseWriter.
func (mr *MockKafkaAccessMockRecorder) CloseWriter(w any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWriter", reflect.TypeOf((*MockKafkaAccess)(nil).CloseWriter), w)
}

// CommitMessages mocks base method.
func (m *MockKafkaAccess) CommitMessages(ctx context.Context, r *kafka.Reader, msgs ...kafka.Message) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, r}
	for _, a := range msgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitMessages", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CommitMessages indicates an expected call of CommitMessages.
func (mr *MockKafkaAccessMockRecorder) CommitMessages(ctx, r any, msgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, r}, msgs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitMessages", reflect.TypeOf((*MockKafkaAccess)(nil).CommitMessages), varargs...)
}

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

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

// NewReader mocks base method.
func (m *MockKafkaAccess) NewReader(ctx context.Context, topic, groupID string) (*kafka.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReader", ctx, topic, groupID)
	ret0, _ := ret[0].(*kafka.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReader indicates an expected call of NewReader.
func (mr *MockKafkaAccessMockRecorder) NewReader(ctx, topic, groupID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReader", reflect.TypeOf((*MockKafkaAccess)(nil).NewReader), ctx, topic, groupID)
}

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

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

// ReadMessage mocks base method.
func (m *MockKafkaAccess) ReadMessage(ctx context.Context, r *kafka.Reader) (kafka.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadMessage", ctx, r)
	ret0, _ := ret[0].(kafka.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WriteMessages mocks base method.
func (m *MockKafkaAccess) WriteMessages(ctx context.Context, w *kafka.Writer, msgs ...kafka.Message) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, w}
	for _, a := range msgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WriteMessages", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteMessages indicates an expected call of WriteMessages.
func (mr *MockKafkaAccessMockRecorder) WriteMessages(ctx, w any, msgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, w}, msgs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteMessages", reflect.TypeOf((*MockKafkaAccess)(nil).WriteMessages), varargs...)
}
