github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/upgrades/upgradevalidation/mocks/lxd_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/provider/lxd (interfaces: ServerFactory,Server)
//
// Generated by this command:
//
//	mockgen -package mocks -destination mocks/lxd_mock.go github.com/juju/juju/provider/lxd ServerFactory,Server
//

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

import (
	context "context"
	reflect "reflect"

	lxd "github.com/canonical/lxd/client"
	api "github.com/canonical/lxd/shared/api"
	lxd0 "github.com/juju/juju/container/lxd"
	base "github.com/juju/juju/core/base"
	network "github.com/juju/juju/core/network"
	environs "github.com/juju/juju/environs"
	lxd1 "github.com/juju/juju/provider/lxd"
	gomock "go.uber.org/mock/gomock"
)

// MockServerFactory is a mock of ServerFactory interface.
type MockServerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockServerFactoryMockRecorder
}

// MockServerFactoryMockRecorder is the mock recorder for MockServerFactory.
type MockServerFactoryMockRecorder struct {
	mock *MockServerFactory
}

// NewMockServerFactory creates a new mock instance.
func NewMockServerFactory(ctrl *gomock.Controller) *MockServerFactory {
	mock := &MockServerFactory{ctrl: ctrl}
	mock.recorder = &MockServerFactoryMockRecorder{mock}
	return mock
}

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

// InsecureRemoteServer mocks base method.
func (m *MockServerFactory) InsecureRemoteServer(arg0 lxd1.CloudSpec) (lxd1.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsecureRemoteServer", arg0)
	ret0, _ := ret[0].(lxd1.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsecureRemoteServer indicates an expected call of InsecureRemoteServer.
func (mr *MockServerFactoryMockRecorder) InsecureRemoteServer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsecureRemoteServer", reflect.TypeOf((*MockServerFactory)(nil).InsecureRemoteServer), arg0)
}

// LocalServer mocks base method.
func (m *MockServerFactory) LocalServer() (lxd1.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LocalServer")
	ret0, _ := ret[0].(lxd1.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RemoteServer mocks base method.
func (m *MockServerFactory) RemoteServer(arg0 lxd1.CloudSpec) (lxd1.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoteServer", arg0)
	ret0, _ := ret[0].(lxd1.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoteServer indicates an expected call of RemoteServer.
func (mr *MockServerFactoryMockRecorder) RemoteServer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteServer", reflect.TypeOf((*MockServerFactory)(nil).RemoteServer), arg0)
}

// MockServer is a mock of Server interface.
type MockServer struct {
	ctrl     *gomock.Controller
	recorder *MockServerMockRecorder
}

// MockServerMockRecorder is the mock recorder for MockServer.
type MockServerMockRecorder struct {
	mock *MockServer
}

// NewMockServer creates a new mock instance.
func NewMockServer(ctrl *gomock.Controller) *MockServer {
	mock := &MockServer{ctrl: ctrl}
	mock.recorder = &MockServerMockRecorder{mock}
	return mock
}

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

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

// AliveContainers indicates an expected call of AliveContainers.
func (mr *MockServerMockRecorder) AliveContainers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AliveContainers", reflect.TypeOf((*MockServer)(nil).AliveContainers), arg0)
}

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

// ContainerAddresses indicates an expected call of ContainerAddresses.
func (mr *MockServerMockRecorder) ContainerAddresses(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerAddresses", reflect.TypeOf((*MockServer)(nil).ContainerAddresses), arg0)
}

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

// CreateCertificate indicates an expected call of CreateCertificate.
func (mr *MockServerMockRecorder) CreateCertificate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockServer)(nil).CreateCertificate), arg0)
}

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

// CreateClientCertificate indicates an expected call of CreateClientCertificate.
func (mr *MockServerMockRecorder) CreateClientCertificate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientCertificate", reflect.TypeOf((*MockServer)(nil).CreateClientCertificate), arg0)
}

// CreateContainerFromSpec mocks base method.
func (m *MockServer) CreateContainerFromSpec(arg0 lxd0.ContainerSpec) (*lxd0.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainerFromSpec", arg0)
	ret0, _ := ret[0].(*lxd0.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerFromSpec indicates an expected call of CreateContainerFromSpec.
func (mr *MockServerMockRecorder) CreateContainerFromSpec(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFromSpec", reflect.TypeOf((*MockServer)(nil).CreateContainerFromSpec), arg0)
}

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

// CreatePool indicates an expected call of CreatePool.
func (mr *MockServerMockRecorder) CreatePool(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePool", reflect.TypeOf((*MockServer)(nil).CreatePool), arg0, arg1, arg2)
}

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

// CreateProfile indicates an expected call of CreateProfile.
func (mr *MockServerMockRecorder) CreateProfile(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfile", reflect.TypeOf((*MockServer)(nil).CreateProfile), arg0)
}

// CreateProfileWithConfig mocks base method.
func (m *MockServer) CreateProfileWithConfig(arg0 string, arg1 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProfileWithConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProfileWithConfig indicates an expected call of CreateProfileWithConfig.
func (mr *MockServerMockRecorder) CreateProfileWithConfig(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfileWithConfig", reflect.TypeOf((*MockServer)(nil).CreateProfileWithConfig), arg0, arg1)
}

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

// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockServerMockRecorder) CreateVolume(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockServer)(nil).CreateVolume), arg0, arg1, arg2)
}

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

// DeleteCertificate indicates an expected call of DeleteCertificate.
func (mr *MockServerMockRecorder) DeleteCertificate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockServer)(nil).DeleteCertificate), arg0)
}

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

// DeleteProfile indicates an expected call of DeleteProfile.
func (mr *MockServerMockRecorder) DeleteProfile(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProfile", reflect.TypeOf((*MockServer)(nil).DeleteProfile), arg0)
}

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

// DeleteStoragePoolVolume indicates an expected call of DeleteStoragePoolVolume.
func (mr *MockServerMockRecorder) DeleteStoragePoolVolume(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).DeleteStoragePoolVolume), arg0, arg1, arg2)
}

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

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

// EnsureDefaultStorage mocks base method.
func (m *MockServer) EnsureDefaultStorage(arg0 *api.Profile, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureDefaultStorage", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureDefaultStorage indicates an expected call of EnsureDefaultStorage.
func (mr *MockServerMockRecorder) EnsureDefaultStorage(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureDefaultStorage", reflect.TypeOf((*MockServer)(nil).EnsureDefaultStorage), arg0, arg1)
}

// FilterContainers mocks base method.
func (m *MockServer) FilterContainers(arg0 string, arg1 ...string) ([]lxd0.Container, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FilterContainers", varargs...)
	ret0, _ := ret[0].([]lxd0.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindImage mocks base method.
func (m *MockServer) FindImage(arg0 context.Context, arg1 base.Base, arg2 string, arg3 api.InstanceType, arg4 []lxd0.ServerSpec, arg5 bool, arg6 environs.StatusCallbackFunc) (lxd0.SourcedImage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindImage", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(lxd0.SourcedImage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindImage indicates an expected call of FindImage.
func (mr *MockServerMockRecorder) FindImage(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindImage", reflect.TypeOf((*MockServer)(nil).FindImage), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// GetCertificate mocks base method.
func (m *MockServer) GetCertificate(arg0 string) (*api.Certificate, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCertificate", arg0)
	ret0, _ := ret[0].(*api.Certificate)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCertificate indicates an expected call of GetCertificate.
func (mr *MockServerMockRecorder) GetCertificate(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockServer)(nil).GetCertificate), arg0)
}

// GetClusterMembers mocks base method.
func (m *MockServer) GetClusterMembers() ([]api.ClusterMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMembers")
	ret0, _ := ret[0].([]api.ClusterMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetConnectionInfo mocks base method.
func (m *MockServer) GetConnectionInfo() (*lxd.ConnectionInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionInfo")
	ret0, _ := ret[0].(*lxd.ConnectionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// GetContainerProfiles indicates an expected call of GetContainerProfiles.
func (mr *MockServerMockRecorder) GetContainerProfiles(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerProfiles", reflect.TypeOf((*MockServer)(nil).GetContainerProfiles), arg0)
}

// GetInstance mocks base method.
func (m *MockServer) GetInstance(arg0 string) (*api.Instance, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance", arg0)
	ret0, _ := ret[0].(*api.Instance)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetInstance indicates an expected call of GetInstance.
func (mr *MockServerMockRecorder) GetInstance(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstance", reflect.TypeOf((*MockServer)(nil).GetInstance), arg0)
}

// GetInstanceState mocks base method.
func (m *MockServer) GetInstanceState(arg0 string) (*api.InstanceState, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceState", arg0)
	ret0, _ := ret[0].(*api.InstanceState)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetInstanceState indicates an expected call of GetInstanceState.
func (mr *MockServerMockRecorder) GetInstanceState(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceState", reflect.TypeOf((*MockServer)(nil).GetInstanceState), arg0)
}

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

// GetNICsFromProfile indicates an expected call of GetNICsFromProfile.
func (mr *MockServerMockRecorder) GetNICsFromProfile(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNICsFromProfile", reflect.TypeOf((*MockServer)(nil).GetNICsFromProfile), arg0)
}

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

// GetNetworkState indicates an expected call of GetNetworkState.
func (mr *MockServerMockRecorder) GetNetworkState(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkState", reflect.TypeOf((*MockServer)(nil).GetNetworkState), arg0)
}

// GetNetworks mocks base method.
func (m *MockServer) GetNetworks() ([]api.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNetworks")
	ret0, _ := ret[0].([]api.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProfile mocks base method.
func (m *MockServer) GetProfile(arg0 string) (*api.Profile, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProfile", arg0)
	ret0, _ := ret[0].(*api.Profile)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetProfile indicates an expected call of GetProfile.
func (mr *MockServerMockRecorder) GetProfile(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfile", reflect.TypeOf((*MockServer)(nil).GetProfile), arg0)
}

// GetServer mocks base method.
func (m *MockServer) GetServer() (*api.Server, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServer")
	ret0, _ := ret[0].(*api.Server)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetStoragePool mocks base method.
func (m *MockServer) GetStoragePool(arg0 string) (*api.StoragePool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePool", arg0)
	ret0, _ := ret[0].(*api.StoragePool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStoragePool indicates an expected call of GetStoragePool.
func (mr *MockServerMockRecorder) GetStoragePool(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePool", reflect.TypeOf((*MockServer)(nil).GetStoragePool), arg0)
}

// GetStoragePoolVolume mocks base method.
func (m *MockServer) GetStoragePoolVolume(arg0, arg1, arg2 string) (*api.StorageVolume, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePoolVolume", arg0, arg1, arg2)
	ret0, _ := ret[0].(*api.StorageVolume)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStoragePoolVolume indicates an expected call of GetStoragePoolVolume.
func (mr *MockServerMockRecorder) GetStoragePoolVolume(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).GetStoragePoolVolume), arg0, arg1, arg2)
}

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

// GetStoragePoolVolumes indicates an expected call of GetStoragePoolVolumes.
func (mr *MockServerMockRecorder) GetStoragePoolVolumes(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumes", reflect.TypeOf((*MockServer)(nil).GetStoragePoolVolumes), arg0)
}

// GetStoragePools mocks base method.
func (m *MockServer) GetStoragePools() ([]api.StoragePool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStoragePools")
	ret0, _ := ret[0].([]api.StoragePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// HasExtension indicates an expected call of HasExtension.
func (mr *MockServerMockRecorder) HasExtension(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasExtension", reflect.TypeOf((*MockServer)(nil).HasExtension), arg0)
}

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

// HasProfile indicates an expected call of HasProfile.
func (mr *MockServerMockRecorder) HasProfile(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasProfile", reflect.TypeOf((*MockServer)(nil).HasProfile), arg0)
}

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

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

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

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

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

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

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

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

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

// RemoveContainer indicates an expected call of RemoveContainer.
func (mr *MockServerMockRecorder) RemoveContainer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockServer)(nil).RemoveContainer), arg0)
}

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

// RemoveContainers indicates an expected call of RemoveContainers.
func (mr *MockServerMockRecorder) RemoveContainers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainers", reflect.TypeOf((*MockServer)(nil).RemoveContainers), arg0)
}

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

// ReplaceOrAddContainerProfile indicates an expected call of ReplaceOrAddContainerProfile.
func (mr *MockServerMockRecorder) ReplaceOrAddContainerProfile(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceOrAddContainerProfile", reflect.TypeOf((*MockServer)(nil).ReplaceOrAddContainerProfile), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// UpdateContainerConfig mocks base method.
func (m *MockServer) UpdateContainerConfig(arg0 string, arg1 map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContainerConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateContainerConfig indicates an expected call of UpdateContainerConfig.
func (mr *MockServerMockRecorder) UpdateContainerConfig(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerConfig", reflect.TypeOf((*MockServer)(nil).UpdateContainerConfig), arg0, arg1)
}

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

// UpdateContainerProfiles indicates an expected call of UpdateContainerProfiles.
func (mr *MockServerMockRecorder) UpdateContainerProfiles(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerProfiles", reflect.TypeOf((*MockServer)(nil).UpdateContainerProfiles), arg0, arg1)
}

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

// UpdateServerConfig indicates an expected call of UpdateServerConfig.
func (mr *MockServerMockRecorder) UpdateServerConfig(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerConfig", reflect.TypeOf((*MockServer)(nil).UpdateServerConfig), arg0)
}

// UpdateStoragePoolVolume mocks base method.
func (m *MockServer) UpdateStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePut, arg4 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStoragePoolVolume indicates an expected call of UpdateStoragePoolVolume.
func (mr *MockServerMockRecorder) UpdateStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePoolVolume", reflect.TypeOf((*MockServer)(nil).UpdateStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
}

// UseProject mocks base method.
func (m *MockServer) UseProject(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UseProject", arg0)
}

// UseProject indicates an expected call of UseProject.
func (mr *MockServerMockRecorder) UseProject(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseProject", reflect.TypeOf((*MockServer)(nil).UseProject), arg0)
}

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

// UseTargetServer indicates an expected call of UseTargetServer.
func (mr *MockServerMockRecorder) UseTargetServer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseTargetServer", reflect.TypeOf((*MockServer)(nil).UseTargetServer), arg0)
}

// VerifyNetworkDevice mocks base method.
func (m *MockServer) VerifyNetworkDevice(arg0 *api.Profile, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyNetworkDevice", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyNetworkDevice indicates an expected call of VerifyNetworkDevice.
func (mr *MockServerMockRecorder) VerifyNetworkDevice(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyNetworkDevice", reflect.TypeOf((*MockServer)(nil).VerifyNetworkDevice), arg0, arg1)
}

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

// WriteContainer indicates an expected call of WriteContainer.
func (mr *MockServerMockRecorder) WriteContainer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteContainer", reflect.TypeOf((*MockServer)(nil).WriteContainer), arg0)
}