// Code generated by MockGen. DO NOT EDIT.
// Source: infra.go
//
// Generated by this command:
//
//	mockgen -source=infra.go -destination=../mocks/infra.go -package=mocks
//

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

import (
	context "context"
	url "net/url"
	reflect "reflect"

	interfaces "github.com/kweaver-ai/adp/execution-factory/operator-integration/server/interfaces"
	gomock "go.uber.org/mock/gomock"
)

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

// 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
}

// Debug mocks base method.
func (m *MockLogger) Debug(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debug", varargs...)
}

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

// Debugf mocks base method.
func (m *MockLogger) Debugf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugf", varargs...)
}

// Debugf indicates an expected call of Debugf.
func (mr *MockLoggerMockRecorder) Debugf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockLogger)(nil).Debugf), varargs...)
}

// Error mocks base method.
func (m *MockLogger) Error(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

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

// Errorf mocks base method.
func (m *MockLogger) Errorf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf.
func (mr *MockLoggerMockRecorder) Errorf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockLogger)(nil).Errorf), varargs...)
}

// Info mocks base method.
func (m *MockLogger) Info(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

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

// Infof mocks base method.
func (m *MockLogger) Infof(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infof", varargs...)
}

// Infof indicates an expected call of Infof.
func (mr *MockLoggerMockRecorder) Infof(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockLogger)(nil).Infof), varargs...)
}

// Warn mocks base method.
func (m *MockLogger) Warn(v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warn", varargs...)
}

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

// Warnf mocks base method.
func (m *MockLogger) Warnf(format string, v ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range v {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warnf", varargs...)
}

// Warnf indicates an expected call of Warnf.
func (mr *MockLoggerMockRecorder) Warnf(format any, v ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, v...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnf", reflect.TypeOf((*MockLogger)(nil).Warnf), varargs...)
}

// WithContext mocks base method.
func (m *MockLogger) WithContext(ctx context.Context) interfaces.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithContext", ctx)
	ret0, _ := ret[0].(interfaces.Logger)
	return ret0
}

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

// MockHTTPClient is a mock of HTTPClient interface.
type MockHTTPClient struct {
	ctrl     *gomock.Controller
	recorder *MockHTTPClientMockRecorder
	isgomock struct{}
}

// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
type MockHTTPClientMockRecorder struct {
	mock *MockHTTPClient
}

// NewMockHTTPClient creates a new mock instance.
func NewMockHTTPClient(ctrl *gomock.Controller) *MockHTTPClient {
	mock := &MockHTTPClient{ctrl: ctrl}
	mock.recorder = &MockHTTPClientMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockHTTPClient) Delete(ctx context.Context, arg1 string, headers map[string]string) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, arg1, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Delete indicates an expected call of Delete.
func (mr *MockHTTPClientMockRecorder) Delete(ctx, arg1, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockHTTPClient)(nil).Delete), ctx, arg1, headers)
}

// DeleteNoUnmarshal mocks base method.
func (m *MockHTTPClient) DeleteNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNoUnmarshal", ctx, arg1, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteNoUnmarshal indicates an expected call of DeleteNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) DeleteNoUnmarshal(ctx, arg1, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).DeleteNoUnmarshal), ctx, arg1, headers)
}

// Get mocks base method.
func (m *MockHTTPClient) Get(ctx context.Context, arg1 string, queryValues url.Values, headers map[string]string) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, arg1, queryValues, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockHTTPClientMockRecorder) Get(ctx, arg1, queryValues, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHTTPClient)(nil).Get), ctx, arg1, queryValues, headers)
}

// GetNoUnmarshal mocks base method.
func (m *MockHTTPClient) GetNoUnmarshal(ctx context.Context, arg1 string, queryValues url.Values, headers map[string]string) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNoUnmarshal", ctx, arg1, queryValues, headers)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetNoUnmarshal indicates an expected call of GetNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) GetNoUnmarshal(ctx, arg1, queryValues, headers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).GetNoUnmarshal), ctx, arg1, queryValues, headers)
}

// Patch mocks base method.
func (m *MockHTTPClient) Patch(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Patch", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Patch indicates an expected call of Patch.
func (mr *MockHTTPClientMockRecorder) Patch(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockHTTPClient)(nil).Patch), ctx, arg1, headers, reqParam)
}

// PatchNoUnmarshal mocks base method.
func (m *MockHTTPClient) PatchNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PatchNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PatchNoUnmarshal indicates an expected call of PatchNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PatchNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PatchNoUnmarshal), ctx, arg1, headers, reqParam)
}

// Post mocks base method.
func (m *MockHTTPClient) Post(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Post", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Post indicates an expected call of Post.
func (mr *MockHTTPClientMockRecorder) Post(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockHTTPClient)(nil).Post), ctx, arg1, headers, reqParam)
}

// PostNoUnmarshal mocks base method.
func (m *MockHTTPClient) PostNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PostNoUnmarshal indicates an expected call of PostNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PostNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PostNoUnmarshal), ctx, arg1, headers, reqParam)
}

// PostStream mocks base method.
func (m *MockHTTPClient) PostStream(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (chan string, chan error, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostStream", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(chan string)
	ret1, _ := ret[1].(chan error)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PostStream indicates an expected call of PostStream.
func (mr *MockHTTPClientMockRecorder) PostStream(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostStream", reflect.TypeOf((*MockHTTPClient)(nil).PostStream), ctx, arg1, headers, reqParam)
}

// Put mocks base method.
func (m *MockHTTPClient) Put(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(any)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Put indicates an expected call of Put.
func (mr *MockHTTPClientMockRecorder) Put(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockHTTPClient)(nil).Put), ctx, arg1, headers, reqParam)
}

// PutNoUnmarshal mocks base method.
func (m *MockHTTPClient) PutNoUnmarshal(ctx context.Context, arg1 string, headers map[string]string, reqParam any) (int, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutNoUnmarshal", ctx, arg1, headers, reqParam)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PutNoUnmarshal indicates an expected call of PutNoUnmarshal.
func (mr *MockHTTPClientMockRecorder) PutNoUnmarshal(ctx, arg1, headers, reqParam any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNoUnmarshal", reflect.TypeOf((*MockHTTPClient)(nil).PutNoUnmarshal), ctx, arg1, headers, reqParam)
}

// MockCache is a mock of Cache interface.
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
	isgomock struct{}
}

// MockCacheMockRecorder is the mock recorder for MockCache.
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance.
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockCache) Delete(key string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Delete", key)
}

// Delete indicates an expected call of Delete.
func (mr *MockCacheMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCache)(nil).Delete), key)
}

// Get mocks base method.
func (m *MockCache) Get(key string) (any, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// Set mocks base method.
func (m *MockCache) Set(key string, value any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Set", key, value)
}

// Set indicates an expected call of Set.
func (mr *MockCacheMockRecorder) Set(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), key, value)
}

// Size mocks base method.
func (m *MockCache) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockCacheMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockCache)(nil).Size))
}

// MockMetricLogger is a mock of MetricLogger interface.
type MockMetricLogger struct {
	ctrl     *gomock.Controller
	recorder *MockMetricLoggerMockRecorder
	isgomock struct{}
}

// MockMetricLoggerMockRecorder is the mock recorder for MockMetricLogger.
type MockMetricLoggerMockRecorder struct {
	mock *MockMetricLogger
}

// NewMockMetricLogger creates a new mock instance.
func NewMockMetricLogger(ctrl *gomock.Controller) *MockMetricLogger {
	mock := &MockMetricLogger{ctrl: ctrl}
	mock.recorder = &MockMetricLoggerMockRecorder{mock}
	return mock
}

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

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

// Log indicates an expected call of Log.
func (mr *MockMetricLoggerMockRecorder) Log(ctx, logType, params any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockMetricLogger)(nil).Log), ctx, logType, params)
}

// MockValidator is a mock of Validator interface.
type MockValidator struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorMockRecorder
	isgomock struct{}
}

// MockValidatorMockRecorder is the mock recorder for MockValidator.
type MockValidatorMockRecorder struct {
	mock *MockValidator
}

// NewMockValidator creates a new mock instance.
func NewMockValidator(ctrl *gomock.Controller) *MockValidator {
	mock := &MockValidator{ctrl: ctrl}
	mock.recorder = &MockValidatorMockRecorder{mock}
	return mock
}

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

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

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

// ValidateOperatorImportCount mocks base method.
func (m *MockValidator) ValidateOperatorImportCount(ctx context.Context, count int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateOperatorImportCount", ctx, count)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ValidateOperatorImportSize mocks base method.
func (m *MockValidator) ValidateOperatorImportSize(ctx context.Context, size int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateOperatorImportSize", ctx, size)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// VisitorParameterDef mocks base method.
func (m *MockValidator) VisitorParameterDef(ctx context.Context, paramDef *interfaces.ParameterDef) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VisitorParameterDef", ctx, paramDef)
	ret0, _ := ret[0].(error)
	return ret0
}

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