/*
  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-advanced-go-wrapper/awssql/driver_infrastructure (interfaces: HostListProviderService,PluginService,PluginManager,CanReleaseResources)

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

import (
	context "context"
	driver "database/sql/driver"
	reflect "reflect"

	driver_infrastructure "github.com/aws/aws-advanced-go-wrapper/awssql/driver_infrastructure"
	host_info_util "github.com/aws/aws-advanced-go-wrapper/awssql/host_info_util"
	"github.com/aws/aws-advanced-go-wrapper/awssql/utils"
	telemetry "github.com/aws/aws-advanced-go-wrapper/awssql/utils/telemetry"
	gomock "github.com/golang/mock/gomock"
)

// MockHostListProviderService is a mock of HostListProviderService interface.
type MockHostListProviderService struct {
	ctrl     *gomock.Controller
	recorder *MockHostListProviderServiceMockRecorder
}

// MockHostListProviderServiceMockRecorder is the mock recorder for MockHostListProviderService.
type MockHostListProviderServiceMockRecorder struct {
	mock *MockHostListProviderService
}

// NewMockHostListProviderService creates a new mock instance.
func NewMockHostListProviderService(ctrl *gomock.Controller) *MockHostListProviderService {
	mock := &MockHostListProviderService{ctrl: ctrl}
	mock.recorder = &MockHostListProviderServiceMockRecorder{mock}
	return mock
}

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

// CreateHostListProvider mocks base method.
func (m *MockHostListProviderService) CreateHostListProvider(arg0 *utils.RWMap[string, string]) driver_infrastructure.HostListProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHostListProvider", arg0)
	ret0, _ := ret[0].(driver_infrastructure.HostListProvider)
	return ret0
}

// CreateHostListProvider indicates an expected call of CreateHostListProvider.
func (mr *MockHostListProviderServiceMockRecorder) CreateHostListProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostListProvider", reflect.TypeOf((*MockHostListProviderService)(nil).CreateHostListProvider), arg0)
}

// GetCurrentConnection mocks base method.
func (m *MockHostListProviderService) GetCurrentConnection() driver.Conn {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentConnection")
	ret0, _ := ret[0].(driver.Conn)
	return ret0
}

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

// GetDialect mocks base method.
func (m *MockHostListProviderService) GetDialect() driver_infrastructure.DatabaseDialect {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDialect")
	ret0, _ := ret[0].(driver_infrastructure.DatabaseDialect)
	return ret0
}

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

// GetHostListProvider mocks base method.
func (m *MockHostListProviderService) GetHostListProvider() driver_infrastructure.HostListProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostListProvider")
	ret0, _ := ret[0].(driver_infrastructure.HostListProvider)
	return ret0
}

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

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

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

// SetHostListProvider mocks base method.
func (m *MockHostListProviderService) SetHostListProvider(arg0 driver_infrastructure.HostListProvider) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHostListProvider", arg0)
}

// SetHostListProvider indicates an expected call of SetHostListProvider.
func (mr *MockHostListProviderServiceMockRecorder) SetHostListProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHostListProvider", reflect.TypeOf((*MockHostListProviderService)(nil).SetHostListProvider), arg0)
}

// SetInitialConnectionHostInfo mocks base method.
func (m *MockHostListProviderService) SetInitialConnectionHostInfo(arg0 *host_info_util.HostInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInitialConnectionHostInfo", arg0)
}

// SetInitialConnectionHostInfo indicates an expected call of SetInitialConnectionHostInfo.
func (mr *MockHostListProviderServiceMockRecorder) SetInitialConnectionHostInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitialConnectionHostInfo", reflect.TypeOf((*MockHostListProviderService)(nil).SetInitialConnectionHostInfo), arg0)
}

// MockPluginService is a mock of PluginService interface.
type MockPluginService struct {
	ctrl     *gomock.Controller
	recorder *MockPluginServiceMockRecorder
}

// MockPluginServiceMockRecorder is the mock recorder for MockPluginService.
type MockPluginServiceMockRecorder struct {
	mock *MockPluginService
}

// NewMockPluginService creates a new mock instance.
func NewMockPluginService(ctrl *gomock.Controller) *MockPluginService {
	mock := &MockPluginService{ctrl: ctrl}
	mock.recorder = &MockPluginServiceMockRecorder{mock}
	return mock
}

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

// AcceptsStrategy mocks base method.
func (m *MockPluginService) AcceptsStrategy(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptsStrategy", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// AcceptsStrategy indicates an expected call of AcceptsStrategy.
func (mr *MockPluginServiceMockRecorder) AcceptsStrategy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptsStrategy", reflect.TypeOf((*MockPluginService)(nil).AcceptsStrategy), arg0)
}

// Connect mocks base method.
func (m *MockPluginService) Connect(arg0 *host_info_util.HostInfo, arg1 *utils.RWMap[string, string], arg2 driver_infrastructure.ConnectionPlugin) (driver.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connect", arg0, arg1, arg2)
	ret0, _ := ret[0].(driver.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Connect indicates an expected call of Connect.
func (mr *MockPluginServiceMockRecorder) Connect(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockPluginService)(nil).Connect), arg0, arg1, arg2)
}

// CreateHostListProvider mocks base method.
func (m *MockPluginService) CreateHostListProvider(arg0 *utils.RWMap[string, string]) driver_infrastructure.HostListProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHostListProvider", arg0)
	ret0, _ := ret[0].(driver_infrastructure.HostListProvider)
	return ret0
}

// CreateHostListProvider indicates an expected call of CreateHostListProvider.
func (mr *MockPluginServiceMockRecorder) CreateHostListProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostListProvider", reflect.TypeOf((*MockPluginService)(nil).CreateHostListProvider), arg0)
}

// FillAliases mocks base method.
func (m *MockPluginService) FillAliases(arg0 driver.Conn, arg1 *host_info_util.HostInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FillAliases", arg0, arg1)
}

// FillAliases indicates an expected call of FillAliases.
func (mr *MockPluginServiceMockRecorder) FillAliases(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FillAliases", reflect.TypeOf((*MockPluginService)(nil).FillAliases), arg0, arg1)
}

// ForceConnect mocks base method.
func (m *MockPluginService) ForceConnect(arg0 *host_info_util.HostInfo, arg1 *utils.RWMap[string, string]) (driver.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceConnect", arg0, arg1)
	ret0, _ := ret[0].(driver.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceConnect indicates an expected call of ForceConnect.
func (mr *MockPluginServiceMockRecorder) ForceConnect(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceConnect", reflect.TypeOf((*MockPluginService)(nil).ForceConnect), arg0, arg1)
}

// ForceRefreshHostList mocks base method.
func (m *MockPluginService) ForceRefreshHostList(arg0 driver.Conn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceRefreshHostList", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForceRefreshHostList indicates an expected call of ForceRefreshHostList.
func (mr *MockPluginServiceMockRecorder) ForceRefreshHostList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceRefreshHostList", reflect.TypeOf((*MockPluginService)(nil).ForceRefreshHostList), arg0)
}

// ForceRefreshHostListWithTimeout mocks base method.
func (m *MockPluginService) ForceRefreshHostListWithTimeout(arg0 bool, arg1 int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceRefreshHostListWithTimeout", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceRefreshHostListWithTimeout indicates an expected call of ForceRefreshHostListWithTimeout.
func (mr *MockPluginServiceMockRecorder) ForceRefreshHostListWithTimeout(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceRefreshHostListWithTimeout", reflect.TypeOf((*MockPluginService)(nil).ForceRefreshHostListWithTimeout), arg0, arg1)
}

// GetBgStatus mocks base method.
func (m *MockPluginService) GetBgStatus(arg0 string) (driver_infrastructure.BlueGreenStatus, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBgStatus", arg0)
	ret0, _ := ret[0].(driver_infrastructure.BlueGreenStatus)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetBgStatus indicates an expected call of GetBgStatus.
func (mr *MockPluginServiceMockRecorder) GetBgStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBgStatus", reflect.TypeOf((*MockPluginService)(nil).GetBgStatus), arg0)
}

// GetConnectionProvider mocks base method.
func (m *MockPluginService) GetConnectionProvider() driver_infrastructure.ConnectionProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionProvider")
	ret0, _ := ret[0].(driver_infrastructure.ConnectionProvider)
	return ret0
}

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

// GetCurrentConnection mocks base method.
func (m *MockPluginService) GetCurrentConnection() driver.Conn {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentConnection")
	ret0, _ := ret[0].(driver.Conn)
	return ret0
}

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

// GetCurrentConnectionRef mocks base method.
func (m *MockPluginService) GetCurrentConnectionRef() *driver.Conn {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentConnectionRef")
	ret0, _ := ret[0].(*driver.Conn)
	return ret0
}

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

// GetCurrentHostInfo mocks base method.
func (m *MockPluginService) GetCurrentHostInfo() (*host_info_util.HostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentHostInfo")
	ret0, _ := ret[0].(*host_info_util.HostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCurrentTx mocks base method.
func (m *MockPluginService) GetCurrentTx() driver.Tx {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentTx")
	ret0, _ := ret[0].(driver.Tx)
	return ret0
}

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

// GetDialect mocks base method.
func (m *MockPluginService) GetDialect() driver_infrastructure.DatabaseDialect {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDialect")
	ret0, _ := ret[0].(driver_infrastructure.DatabaseDialect)
	return ret0
}

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

// GetHostInfoByStrategy mocks base method.
func (m *MockPluginService) GetHostInfoByStrategy(arg0 host_info_util.HostRole, arg1 string, arg2 []*host_info_util.HostInfo) (*host_info_util.HostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostInfoByStrategy", arg0, arg1, arg2)
	ret0, _ := ret[0].(*host_info_util.HostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostInfoByStrategy indicates an expected call of GetHostInfoByStrategy.
func (mr *MockPluginServiceMockRecorder) GetHostInfoByStrategy(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostInfoByStrategy", reflect.TypeOf((*MockPluginService)(nil).GetHostInfoByStrategy), arg0, arg1, arg2)
}

// GetHostListProvider mocks base method.
func (m *MockPluginService) GetHostListProvider() driver_infrastructure.HostListProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostListProvider")
	ret0, _ := ret[0].(driver_infrastructure.HostListProvider)
	return ret0
}

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

// GetHostRole mocks base method.
func (m *MockPluginService) GetHostRole(arg0 driver.Conn) host_info_util.HostRole {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostRole", arg0)
	ret0, _ := ret[0].(host_info_util.HostRole)
	return ret0
}

// GetHostRole indicates an expected call of GetHostRole.
func (mr *MockPluginServiceMockRecorder) GetHostRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostRole", reflect.TypeOf((*MockPluginService)(nil).GetHostRole), arg0)
}

// GetHostSelectorStrategy mocks base method.
func (m *MockPluginService) GetHostSelectorStrategy(arg0 string) (driver_infrastructure.HostSelector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostSelectorStrategy", arg0)
	ret0, _ := ret[0].(driver_infrastructure.HostSelector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostSelectorStrategy indicates an expected call of GetHostSelectorStrategy.
func (mr *MockPluginServiceMockRecorder) GetHostSelectorStrategy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostSelectorStrategy", reflect.TypeOf((*MockPluginService)(nil).GetHostSelectorStrategy), arg0)
}

// GetHosts mocks base method.
func (m *MockPluginService) GetHosts() []*host_info_util.HostInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHosts")
	ret0, _ := ret[0].([]*host_info_util.HostInfo)
	return ret0
}

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

// GetInitialConnectionHostInfo mocks base method.
func (m *MockPluginService) GetInitialConnectionHostInfo() *host_info_util.HostInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInitialConnectionHostInfo")
	ret0, _ := ret[0].(*host_info_util.HostInfo)
	return ret0
}

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

// GetProperties mocks base method.
func (m *MockPluginService) GetProperties() *utils.RWMap[string, string] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProperties")
	ret0, _ := ret[0].(*utils.RWMap[string, string])
	return ret0
}

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

// GetTargetDriverDialect mocks base method.
func (m *MockPluginService) GetTargetDriverDialect() driver_infrastructure.DriverDialect {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTargetDriverDialect")
	ret0, _ := ret[0].(driver_infrastructure.DriverDialect)
	return ret0
}

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

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

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

// GetTelemetryFactory mocks base method.
func (m *MockPluginService) GetTelemetryFactory() telemetry.TelemetryFactory {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTelemetryFactory")
	ret0, _ := ret[0].(telemetry.TelemetryFactory)
	return ret0
}

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

// GetUpdatedHostListWithTimeout mocks base method.
func (m *MockPluginService) GetUpdatedHostListWithTimeout(arg0 bool, arg1 int) ([]*host_info_util.HostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdatedHostListWithTimeout", arg0, arg1)
	ret0, _ := ret[0].([]*host_info_util.HostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUpdatedHostListWithTimeout indicates an expected call of GetUpdatedHostListWithTimeout.
func (mr *MockPluginServiceMockRecorder) GetUpdatedHostListWithTimeout(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdatedHostListWithTimeout", reflect.TypeOf((*MockPluginService)(nil).GetUpdatedHostListWithTimeout), arg0, arg1)
}

// IdentifyConnection mocks base method.
func (m *MockPluginService) IdentifyConnection(arg0 driver.Conn) (*host_info_util.HostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdentifyConnection", arg0)
	ret0, _ := ret[0].(*host_info_util.HostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IdentifyConnection indicates an expected call of IdentifyConnection.
func (mr *MockPluginServiceMockRecorder) IdentifyConnection(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentifyConnection", reflect.TypeOf((*MockPluginService)(nil).IdentifyConnection), arg0)
}

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

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

// IsLoginError mocks base method.
func (m *MockPluginService) IsLoginError(arg0 error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsLoginError", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsLoginError indicates an expected call of IsLoginError.
func (mr *MockPluginServiceMockRecorder) IsLoginError(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLoginError", reflect.TypeOf((*MockPluginService)(nil).IsLoginError), arg0)
}

// IsNetworkError mocks base method.
func (m *MockPluginService) IsNetworkError(arg0 error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNetworkError", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNetworkError indicates an expected call of IsNetworkError.
func (mr *MockPluginServiceMockRecorder) IsNetworkError(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNetworkError", reflect.TypeOf((*MockPluginService)(nil).IsNetworkError), arg0)
}

// IsPluginInUse mocks base method.
func (m *MockPluginService) IsPluginInUse(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPluginInUse", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPluginInUse indicates an expected call of IsPluginInUse.
func (mr *MockPluginServiceMockRecorder) IsPluginInUse(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPluginInUse", reflect.TypeOf((*MockPluginService)(nil).IsPluginInUse), arg0)
}

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

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

// RefreshHostList mocks base method.
func (m *MockPluginService) RefreshHostList(arg0 driver.Conn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshHostList", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshHostList indicates an expected call of RefreshHostList.
func (mr *MockPluginServiceMockRecorder) RefreshHostList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshHostList", reflect.TypeOf((*MockPluginService)(nil).RefreshHostList), arg0)
}

// ResetSession mocks base method.
func (m *MockPluginService) ResetSession() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetSession")
}

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

// SetAvailability mocks base method.
func (m *MockPluginService) SetAvailability(arg0 map[string]bool, arg1 host_info_util.HostAvailability) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAvailability", arg0, arg1)
}

// SetAvailability indicates an expected call of SetAvailability.
func (mr *MockPluginServiceMockRecorder) SetAvailability(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAvailability", reflect.TypeOf((*MockPluginService)(nil).SetAvailability), arg0, arg1)
}

// SetBgStatus mocks base method.
func (m *MockPluginService) SetBgStatus(arg0 driver_infrastructure.BlueGreenStatus, arg1 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBgStatus", arg0, arg1)
}

// SetBgStatus indicates an expected call of SetBgStatus.
func (mr *MockPluginServiceMockRecorder) SetBgStatus(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBgStatus", reflect.TypeOf((*MockPluginService)(nil).SetBgStatus), arg0, arg1)
}

// SetCurrentConnection mocks base method.
func (m *MockPluginService) SetCurrentConnection(arg0 driver.Conn, arg1 *host_info_util.HostInfo, arg2 driver_infrastructure.ConnectionPlugin) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCurrentConnection", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetCurrentConnection indicates an expected call of SetCurrentConnection.
func (mr *MockPluginServiceMockRecorder) SetCurrentConnection(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentConnection", reflect.TypeOf((*MockPluginService)(nil).SetCurrentConnection), arg0, arg1, arg2)
}

// SetCurrentTx mocks base method.
func (m *MockPluginService) SetCurrentTx(arg0 driver.Tx) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentTx", arg0)
}

// SetCurrentTx indicates an expected call of SetCurrentTx.
func (mr *MockPluginServiceMockRecorder) SetCurrentTx(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentTx", reflect.TypeOf((*MockPluginService)(nil).SetCurrentTx), arg0)
}

// SetDialect mocks base method.
func (m *MockPluginService) SetDialect(arg0 driver_infrastructure.DatabaseDialect) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDialect", arg0)
}

// SetDialect indicates an expected call of SetDialect.
func (mr *MockPluginServiceMockRecorder) SetDialect(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDialect", reflect.TypeOf((*MockPluginService)(nil).SetDialect), arg0)
}

// SetHostListProvider mocks base method.
func (m *MockPluginService) SetHostListProvider(arg0 driver_infrastructure.HostListProvider) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHostListProvider", arg0)
}

// SetHostListProvider indicates an expected call of SetHostListProvider.
func (mr *MockPluginServiceMockRecorder) SetHostListProvider(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHostListProvider", reflect.TypeOf((*MockPluginService)(nil).SetHostListProvider), arg0)
}

// SetInTransaction mocks base method.
func (m *MockPluginService) SetInTransaction(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInTransaction", arg0)
}

// SetInTransaction indicates an expected call of SetInTransaction.
func (mr *MockPluginServiceMockRecorder) SetInTransaction(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInTransaction", reflect.TypeOf((*MockPluginService)(nil).SetInTransaction), arg0)
}

// SetInitialConnectionHostInfo mocks base method.
func (m *MockPluginService) SetInitialConnectionHostInfo(arg0 *host_info_util.HostInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInitialConnectionHostInfo", arg0)
}

// SetInitialConnectionHostInfo indicates an expected call of SetInitialConnectionHostInfo.
func (mr *MockPluginServiceMockRecorder) SetInitialConnectionHostInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitialConnectionHostInfo", reflect.TypeOf((*MockPluginService)(nil).SetInitialConnectionHostInfo), arg0)
}

// SetTelemetryContext mocks base method.
func (m *MockPluginService) SetTelemetryContext(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTelemetryContext", arg0)
}

// SetTelemetryContext indicates an expected call of SetTelemetryContext.
func (mr *MockPluginServiceMockRecorder) SetTelemetryContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTelemetryContext", reflect.TypeOf((*MockPluginService)(nil).SetTelemetryContext), arg0)
}

// UpdateDialect mocks base method.
func (m *MockPluginService) UpdateDialect(arg0 driver.Conn) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateDialect", arg0)
}

// UpdateDialect indicates an expected call of UpdateDialect.
func (mr *MockPluginServiceMockRecorder) UpdateDialect(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDialect", reflect.TypeOf((*MockPluginService)(nil).UpdateDialect), arg0)
}

// UpdateState mocks base method.
func (m *MockPluginService) UpdateState(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "UpdateState", varargs...)
}

// UpdateState indicates an expected call of UpdateState.
func (mr *MockPluginServiceMockRecorder) UpdateState(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateState", reflect.TypeOf((*MockPluginService)(nil).UpdateState), varargs...)
}

// MockPluginManager is a mock of PluginManager interface.
type MockPluginManager struct {
	ctrl     *gomock.Controller
	recorder *MockPluginManagerMockRecorder
}

// MockPluginManagerMockRecorder is the mock recorder for MockPluginManager.
type MockPluginManagerMockRecorder struct {
	mock *MockPluginManager
}

// NewMockPluginManager creates a new mock instance.
func NewMockPluginManager(ctrl *gomock.Controller) *MockPluginManager {
	mock := &MockPluginManager{ctrl: ctrl}
	mock.recorder = &MockPluginManagerMockRecorder{mock}
	return mock
}

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

// AcceptsStrategy mocks base method.
func (m *MockPluginManager) AcceptsStrategy(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcceptsStrategy", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// AcceptsStrategy indicates an expected call of AcceptsStrategy.
func (mr *MockPluginManagerMockRecorder) AcceptsStrategy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptsStrategy", reflect.TypeOf((*MockPluginManager)(nil).AcceptsStrategy), arg0)
}

// Connect mocks base method.
func (m *MockPluginManager) Connect(arg0 *host_info_util.HostInfo, arg1 *utils.RWMap[string, string], arg2 bool, arg3 driver_infrastructure.ConnectionPlugin) (driver.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connect", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(driver.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Connect indicates an expected call of Connect.
func (mr *MockPluginManagerMockRecorder) Connect(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockPluginManager)(nil).Connect), arg0, arg1, arg2, arg3)
}

// Execute mocks base method.
func (m *MockPluginManager) Execute(arg0 driver.Conn, arg1 string, arg2 driver_infrastructure.ExecuteFunc, arg3 ...interface{}) (interface{}, interface{}, bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Execute", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(interface{})
	ret2, _ := ret[2].(bool)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// Execute indicates an expected call of Execute.
func (mr *MockPluginManagerMockRecorder) Execute(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockPluginManager)(nil).Execute), varargs...)
}

// ForceConnect mocks base method.
func (m *MockPluginManager) ForceConnect(arg0 *host_info_util.HostInfo, arg1 *utils.RWMap[string, string], arg2 bool) (driver.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceConnect", arg0, arg1, arg2)
	ret0, _ := ret[0].(driver.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceConnect indicates an expected call of ForceConnect.
func (mr *MockPluginManagerMockRecorder) ForceConnect(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceConnect", reflect.TypeOf((*MockPluginManager)(nil).ForceConnect), arg0, arg1, arg2)
}

// GetConnectionProviderManager mocks base method.
func (m *MockPluginManager) GetConnectionProviderManager() driver_infrastructure.ConnectionProviderManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionProviderManager")
	ret0, _ := ret[0].(driver_infrastructure.ConnectionProviderManager)
	return ret0
}

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

// GetDefaultConnectionProvider mocks base method.
func (m *MockPluginManager) GetDefaultConnectionProvider() driver_infrastructure.ConnectionProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultConnectionProvider")
	ret0, _ := ret[0].(driver_infrastructure.ConnectionProvider)
	return ret0
}

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

// GetEffectiveConnectionProvider mocks base method.
func (m *MockPluginManager) GetEffectiveConnectionProvider() driver_infrastructure.ConnectionProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEffectiveConnectionProvider")
	ret0, _ := ret[0].(driver_infrastructure.ConnectionProvider)
	return ret0
}

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

// GetHostInfoByStrategy mocks base method.
func (m *MockPluginManager) GetHostInfoByStrategy(arg0 host_info_util.HostRole, arg1 string, arg2 []*host_info_util.HostInfo) (*host_info_util.HostInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostInfoByStrategy", arg0, arg1, arg2)
	ret0, _ := ret[0].(*host_info_util.HostInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostInfoByStrategy indicates an expected call of GetHostInfoByStrategy.
func (mr *MockPluginManagerMockRecorder) GetHostInfoByStrategy(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostInfoByStrategy", reflect.TypeOf((*MockPluginManager)(nil).GetHostInfoByStrategy), arg0, arg1, arg2)
}

// GetHostSelectorStrategy mocks base method.
func (m *MockPluginManager) GetHostSelectorStrategy(arg0 string) (driver_infrastructure.HostSelector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostSelectorStrategy", arg0)
	ret0, _ := ret[0].(driver_infrastructure.HostSelector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHostSelectorStrategy indicates an expected call of GetHostSelectorStrategy.
func (mr *MockPluginManagerMockRecorder) GetHostSelectorStrategy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostSelectorStrategy", reflect.TypeOf((*MockPluginManager)(nil).GetHostSelectorStrategy), arg0)
}

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

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

// GetTelemetryFactory mocks base method.
func (m *MockPluginManager) GetTelemetryFactory() telemetry.TelemetryFactory {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTelemetryFactory")
	ret0, _ := ret[0].(telemetry.TelemetryFactory)
	return ret0
}

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

// Init mocks base method.
func (m *MockPluginManager) Init(arg0 driver_infrastructure.PluginService, arg1 []driver_infrastructure.ConnectionPlugin) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockPluginManagerMockRecorder) Init(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockPluginManager)(nil).Init), arg0, arg1)
}

// InitHostProvider mocks base method.
func (m *MockPluginManager) InitHostProvider(arg0 *utils.RWMap[string, string], arg1 driver_infrastructure.HostListProviderService) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitHostProvider", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// InitHostProvider indicates an expected call of InitHostProvider.
func (mr *MockPluginManagerMockRecorder) InitHostProvider(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitHostProvider", reflect.TypeOf((*MockPluginManager)(nil).InitHostProvider), arg0, arg1)
}

// IsPluginInUse mocks base method.
func (m *MockPluginManager) IsPluginInUse(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPluginInUse", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPluginInUse indicates an expected call of IsPluginInUse.
func (mr *MockPluginManagerMockRecorder) IsPluginInUse(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPluginInUse", reflect.TypeOf((*MockPluginManager)(nil).IsPluginInUse), arg0)
}

// NotifyConnectionChanged mocks base method.
func (m *MockPluginManager) NotifyConnectionChanged(arg0 map[driver_infrastructure.HostChangeOptions]bool, arg1 driver_infrastructure.ConnectionPlugin) map[driver_infrastructure.OldConnectionSuggestedAction]bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyConnectionChanged", arg0, arg1)
	ret0, _ := ret[0].(map[driver_infrastructure.OldConnectionSuggestedAction]bool)
	return ret0
}

// NotifyConnectionChanged indicates an expected call of NotifyConnectionChanged.
func (mr *MockPluginManagerMockRecorder) NotifyConnectionChanged(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyConnectionChanged", reflect.TypeOf((*MockPluginManager)(nil).NotifyConnectionChanged), arg0, arg1)
}

// NotifyHostListChanged mocks base method.
func (m *MockPluginManager) NotifyHostListChanged(arg0 map[string]map[driver_infrastructure.HostChangeOptions]bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyHostListChanged", arg0)
}

// NotifyHostListChanged indicates an expected call of NotifyHostListChanged.
func (mr *MockPluginManagerMockRecorder) NotifyHostListChanged(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyHostListChanged", reflect.TypeOf((*MockPluginManager)(nil).NotifyHostListChanged), arg0)
}

// NotifySubscribedPlugins mocks base method.
func (m *MockPluginManager) NotifySubscribedPlugins(arg0 string, arg1 driver_infrastructure.PluginExecFunc, arg2 driver_infrastructure.ConnectionPlugin) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifySubscribedPlugins", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// NotifySubscribedPlugins indicates an expected call of NotifySubscribedPlugins.
func (mr *MockPluginManagerMockRecorder) NotifySubscribedPlugins(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifySubscribedPlugins", reflect.TypeOf((*MockPluginManager)(nil).NotifySubscribedPlugins), arg0, arg1, arg2)
}

// ReleaseResources mocks base method.
func (m *MockPluginManager) ReleaseResources() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResources")
}

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

// SetTelemetryContext mocks base method.
func (m *MockPluginManager) SetTelemetryContext(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTelemetryContext", arg0)
}

// SetTelemetryContext indicates an expected call of SetTelemetryContext.
func (mr *MockPluginManagerMockRecorder) SetTelemetryContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTelemetryContext", reflect.TypeOf((*MockPluginManager)(nil).SetTelemetryContext), arg0)
}

// UnwrapPlugin mocks base method.
func (m *MockPluginManager) UnwrapPlugin(arg0 string) driver_infrastructure.ConnectionPlugin {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnwrapPlugin", arg0)
	ret0, _ := ret[0].(driver_infrastructure.ConnectionPlugin)
	return ret0
}

// UnwrapPlugin indicates an expected call of UnwrapPlugin.
func (mr *MockPluginManagerMockRecorder) UnwrapPlugin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnwrapPlugin", reflect.TypeOf((*MockPluginManager)(nil).UnwrapPlugin), arg0)
}

// MockCanReleaseResources is a mock of CanReleaseResources interface.
type MockCanReleaseResources struct {
	ctrl     *gomock.Controller
	recorder *MockCanReleaseResourcesMockRecorder
}

// MockCanReleaseResourcesMockRecorder is the mock recorder for MockCanReleaseResources.
type MockCanReleaseResourcesMockRecorder struct {
	mock *MockCanReleaseResources
}

// NewMockCanReleaseResources creates a new mock instance.
func NewMockCanReleaseResources(ctrl *gomock.Controller) *MockCanReleaseResources {
	mock := &MockCanReleaseResources{ctrl: ctrl}
	mock.recorder = &MockCanReleaseResourcesMockRecorder{mock}
	return mock
}

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

// ReleaseResources mocks base method.
func (m *MockCanReleaseResources) ReleaseResources() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReleaseResources")
}

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