// Code generated by MockGen. DO NOT EDIT.
// Source: open_search.go
//
// Generated by this command:
//
//	mockgen -package cmpmock -source open_search.go -destination ./cmpmock/open_search_mock.go
//

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

import (
	context "context"
	io "io"
	reflect "reflect"

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

// MockIOpsCmp is a mock of IOpsCmp interface.
type MockIOpsCmp struct {
	ctrl     *gomock.Controller
	recorder *MockIOpsCmpMockRecorder
	isgomock struct{}
}

// MockIOpsCmpMockRecorder is the mock recorder for MockIOpsCmp.
type MockIOpsCmpMockRecorder struct {
	mock *MockIOpsCmp
}

// NewMockIOpsCmp creates a new mock instance.
func NewMockIOpsCmp(ctrl *gomock.Controller) *MockIOpsCmp {
	mock := &MockIOpsCmp{ctrl: ctrl}
	mock.recorder = &MockIOpsCmpMockRecorder{mock}
	return mock
}

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

// BatchCreate mocks base method.
func (m *MockIOpsCmp) BatchCreate(ctx context.Context, index string, data []map[string]any, isWithID bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreate", ctx, index, data, isWithID)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCreate indicates an expected call of BatchCreate.
func (mr *MockIOpsCmpMockRecorder) BatchCreate(ctx, index, data, isWithID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreate", reflect.TypeOf((*MockIOpsCmp)(nil).BatchCreate), ctx, index, data, isWithID)
}

// BatchCreateInterface mocks base method.
func (m *MockIOpsCmp) BatchCreateInterface(ctx context.Context, index string, docs any, isWithID bool, batchSize int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateInterface", ctx, index, docs, isWithID, batchSize)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCreateInterface indicates an expected call of BatchCreateInterface.
func (mr *MockIOpsCmpMockRecorder) BatchCreateInterface(ctx, index, docs, isWithID, batchSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateInterface", reflect.TypeOf((*MockIOpsCmp)(nil).BatchCreateInterface), ctx, index, docs, isWithID, batchSize)
}

// Create mocks base method.
func (m *MockIOpsCmp) Create(c context.Context, index, docID string, docReader io.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", c, index, docID, docReader)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockIOpsCmpMockRecorder) Create(c, index, docID, docReader any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIOpsCmp)(nil).Create), c, index, docID, docReader)
}

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

// CreateIndex indicates an expected call of CreateIndex.
func (mr *MockIOpsCmpMockRecorder) CreateIndex(ctx, index, mapping, setting any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIndex", reflect.TypeOf((*MockIOpsCmp)(nil).CreateIndex), ctx, index, mapping, setting)
}

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

// CreateInterfaceNoID indicates an expected call of CreateInterfaceNoID.
func (mr *MockIOpsCmpMockRecorder) CreateInterfaceNoID(ctx, index, i any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInterfaceNoID", reflect.TypeOf((*MockIOpsCmp)(nil).CreateInterfaceNoID), ctx, index, i)
}

// DeleteDocByField mocks base method.
func (m *MockIOpsCmp) DeleteDocByField(ctx context.Context, index, field string, value any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDocByField", ctx, index, field, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDocByField indicates an expected call of DeleteDocByField.
func (mr *MockIOpsCmpMockRecorder) DeleteDocByField(ctx, index, field, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocByField", reflect.TypeOf((*MockIOpsCmp)(nil).DeleteDocByField), ctx, index, field, value)
}

// DeleteDocsByFieldRange mocks base method.
func (m *MockIOpsCmp) DeleteDocsByFieldRange(ctx context.Context, index, field string, from, to any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDocsByFieldRange", ctx, index, field, from, to)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDocsByFieldRange indicates an expected call of DeleteDocsByFieldRange.
func (mr *MockIOpsCmpMockRecorder) DeleteDocsByFieldRange(ctx, index, field, from, to any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocsByFieldRange", reflect.TypeOf((*MockIOpsCmp)(nil).DeleteDocsByFieldRange), ctx, index, field, from, to)
}

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

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

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

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