github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/container/lxd/testing/lxd_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/lxc/lxd/client (interfaces: Operation,RemoteOperation,Server,ImageServer,ContainerServer)

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

import (
	io "io"
	http "net/http"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	websocket "github.com/gorilla/websocket"
	client "github.com/lxc/lxd/client"
	api "github.com/lxc/lxd/shared/api"
)

// MockOperation is a mock of Operation interface
type MockOperation struct {
	ctrl     *gomock.Controller
	recorder *MockOperationMockRecorder
}

// MockOperationMockRecorder is the mock recorder for MockOperation
type MockOperationMockRecorder struct {
	mock *MockOperation
}

// NewMockOperation creates a new mock instance
func NewMockOperation(ctrl *gomock.Controller) *MockOperation {
	mock := &MockOperation{ctrl: ctrl}
	mock.recorder = &MockOperationMockRecorder{mock}
	return mock
}

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

// AddHandler mocks base method
func (m *MockOperation) AddHandler(arg0 func(api.Operation)) (*client.EventTarget, error) {
	ret := m.ctrl.Call(m, "AddHandler", arg0)
	ret0, _ := ret[0].(*client.EventTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddHandler indicates an expected call of AddHandler
func (mr *MockOperationMockRecorder) AddHandler(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHandler", reflect.TypeOf((*MockOperation)(nil).AddHandler), arg0)
}

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

// Cancel indicates an expected call of Cancel
func (mr *MockOperationMockRecorder) Cancel() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockOperation)(nil).Cancel))
}

// Get mocks base method
func (m *MockOperation) Get() api.Operation {
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(api.Operation)
	return ret0
}

// Get indicates an expected call of Get
func (mr *MockOperationMockRecorder) Get() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOperation)(nil).Get))
}

// GetWebsocket mocks base method
func (m *MockOperation) GetWebsocket(arg0 string) (*websocket.Conn, error) {
	ret := m.ctrl.Call(m, "GetWebsocket", arg0)
	ret0, _ := ret[0].(*websocket.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWebsocket indicates an expected call of GetWebsocket
func (mr *MockOperationMockRecorder) GetWebsocket(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebsocket", reflect.TypeOf((*MockOperation)(nil).GetWebsocket), arg0)
}

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

// Refresh indicates an expected call of Refresh
func (mr *MockOperationMockRecorder) Refresh() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Refresh", reflect.TypeOf((*MockOperation)(nil).Refresh))
}

// RemoveHandler mocks base method
func (m *MockOperation) RemoveHandler(arg0 *client.EventTarget) error {
	ret := m.ctrl.Call(m, "RemoveHandler", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveHandler indicates an expected call of RemoveHandler
func (mr *MockOperationMockRecorder) RemoveHandler(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveHandler", reflect.TypeOf((*MockOperation)(nil).RemoveHandler), arg0)
}

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

// Wait indicates an expected call of Wait
func (mr *MockOperationMockRecorder) Wait() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockOperation)(nil).Wait))
}

// MockRemoteOperation is a mock of RemoteOperation interface
type MockRemoteOperation struct {
	ctrl     *gomock.Controller
	recorder *MockRemoteOperationMockRecorder
}

// MockRemoteOperationMockRecorder is the mock recorder for MockRemoteOperation
type MockRemoteOperationMockRecorder struct {
	mock *MockRemoteOperation
}

// NewMockRemoteOperation creates a new mock instance
func NewMockRemoteOperation(ctrl *gomock.Controller) *MockRemoteOperation {
	mock := &MockRemoteOperation{ctrl: ctrl}
	mock.recorder = &MockRemoteOperationMockRecorder{mock}
	return mock
}

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

// AddHandler mocks base method
func (m *MockRemoteOperation) AddHandler(arg0 func(api.Operation)) (*client.EventTarget, error) {
	ret := m.ctrl.Call(m, "AddHandler", arg0)
	ret0, _ := ret[0].(*client.EventTarget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddHandler indicates an expected call of AddHandler
func (mr *MockRemoteOperationMockRecorder) AddHandler(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHandler", reflect.TypeOf((*MockRemoteOperation)(nil).AddHandler), arg0)
}

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

// CancelTarget indicates an expected call of CancelTarget
func (mr *MockRemoteOperationMockRecorder) CancelTarget() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelTarget", reflect.TypeOf((*MockRemoteOperation)(nil).CancelTarget))
}

// GetTarget mocks base method
func (m *MockRemoteOperation) GetTarget() (*api.Operation, error) {
	ret := m.ctrl.Call(m, "GetTarget")
	ret0, _ := ret[0].(*api.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTarget indicates an expected call of GetTarget
func (mr *MockRemoteOperationMockRecorder) GetTarget() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTarget", reflect.TypeOf((*MockRemoteOperation)(nil).GetTarget))
}

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

// Wait indicates an expected call of Wait
func (mr *MockRemoteOperationMockRecorder) Wait() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockRemoteOperation)(nil).Wait))
}

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

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

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

// GetHTTPClient mocks base method
func (m *MockServer) GetHTTPClient() (*http.Client, error) {
	ret := m.ctrl.Call(m, "GetHTTPClient")
	ret0, _ := ret[0].(*http.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockImageServer is a mock of ImageServer interface
type MockImageServer struct {
	ctrl     *gomock.Controller
	recorder *MockImageServerMockRecorder
}

// MockImageServerMockRecorder is the mock recorder for MockImageServer
type MockImageServerMockRecorder struct {
	mock *MockImageServer
}

// NewMockImageServer creates a new mock instance
func NewMockImageServer(ctrl *gomock.Controller) *MockImageServer {
	mock := &MockImageServer{ctrl: ctrl}
	mock.recorder = &MockImageServerMockRecorder{mock}
	return mock
}

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

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

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

// GetHTTPClient mocks base method
func (m *MockImageServer) GetHTTPClient() (*http.Client, error) {
	ret := m.ctrl.Call(m, "GetHTTPClient")
	ret0, _ := ret[0].(*http.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHTTPClient indicates an expected call of GetHTTPClient
func (mr *MockImageServerMockRecorder) GetHTTPClient() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockImageServer)(nil).GetHTTPClient))
}

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

// GetImage indicates an expected call of GetImage
func (mr *MockImageServerMockRecorder) GetImage(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImage", reflect.TypeOf((*MockImageServer)(nil).GetImage), arg0)
}

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

// GetImageAlias indicates an expected call of GetImageAlias
func (mr *MockImageServerMockRecorder) GetImageAlias(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAlias", reflect.TypeOf((*MockImageServer)(nil).GetImageAlias), arg0)
}

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

// GetImageAliasNames indicates an expected call of GetImageAliasNames
func (mr *MockImageServerMockRecorder) GetImageAliasNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliasNames", reflect.TypeOf((*MockImageServer)(nil).GetImageAliasNames))
}

// GetImageAliases mocks base method
func (m *MockImageServer) GetImageAliases() ([]api.ImageAliasesEntry, error) {
	ret := m.ctrl.Call(m, "GetImageAliases")
	ret0, _ := ret[0].([]api.ImageAliasesEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageAliases indicates an expected call of GetImageAliases
func (mr *MockImageServerMockRecorder) GetImageAliases() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliases", reflect.TypeOf((*MockImageServer)(nil).GetImageAliases))
}

// GetImageFile mocks base method
func (m *MockImageServer) GetImageFile(arg0 string, arg1 client.ImageFileRequest) (*client.ImageFileResponse, error) {
	ret := m.ctrl.Call(m, "GetImageFile", arg0, arg1)
	ret0, _ := ret[0].(*client.ImageFileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageFile indicates an expected call of GetImageFile
func (mr *MockImageServerMockRecorder) GetImageFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFile", reflect.TypeOf((*MockImageServer)(nil).GetImageFile), arg0, arg1)
}

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

// GetImageFingerprints indicates an expected call of GetImageFingerprints
func (mr *MockImageServerMockRecorder) GetImageFingerprints() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFingerprints", reflect.TypeOf((*MockImageServer)(nil).GetImageFingerprints))
}

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

// GetImageSecret indicates an expected call of GetImageSecret
func (mr *MockImageServerMockRecorder) GetImageSecret(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageSecret", reflect.TypeOf((*MockImageServer)(nil).GetImageSecret), arg0)
}

// GetImages mocks base method
func (m *MockImageServer) GetImages() ([]api.Image, error) {
	ret := m.ctrl.Call(m, "GetImages")
	ret0, _ := ret[0].([]api.Image)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImages indicates an expected call of GetImages
func (mr *MockImageServerMockRecorder) GetImages() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImages", reflect.TypeOf((*MockImageServer)(nil).GetImages))
}

// GetPrivateImage mocks base method
func (m *MockImageServer) GetPrivateImage(arg0, arg1 string) (*api.Image, string, error) {
	ret := m.ctrl.Call(m, "GetPrivateImage", arg0, arg1)
	ret0, _ := ret[0].(*api.Image)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPrivateImage indicates an expected call of GetPrivateImage
func (mr *MockImageServerMockRecorder) GetPrivateImage(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImage", reflect.TypeOf((*MockImageServer)(nil).GetPrivateImage), arg0, arg1)
}

// GetPrivateImageFile mocks base method
func (m *MockImageServer) GetPrivateImageFile(arg0, arg1 string, arg2 client.ImageFileRequest) (*client.ImageFileResponse, error) {
	ret := m.ctrl.Call(m, "GetPrivateImageFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(*client.ImageFileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateImageFile indicates an expected call of GetPrivateImageFile
func (mr *MockImageServerMockRecorder) GetPrivateImageFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImageFile", reflect.TypeOf((*MockImageServer)(nil).GetPrivateImageFile), arg0, arg1, arg2)
}

// MockContainerServer is a mock of ContainerServer interface
type MockContainerServer struct {
	ctrl     *gomock.Controller
	recorder *MockContainerServerMockRecorder
}

// MockContainerServerMockRecorder is the mock recorder for MockContainerServer
type MockContainerServerMockRecorder struct {
	mock *MockContainerServer
}

// NewMockContainerServer creates a new mock instance
func NewMockContainerServer(ctrl *gomock.Controller) *MockContainerServer {
	mock := &MockContainerServer{ctrl: ctrl}
	mock.recorder = &MockContainerServerMockRecorder{mock}
	return mock
}

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

// ConsoleContainer mocks base method
func (m *MockContainerServer) ConsoleContainer(arg0 string, arg1 api.ContainerConsolePost, arg2 *client.ContainerConsoleArgs) (client.Operation, error) {
	ret := m.ctrl.Call(m, "ConsoleContainer", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConsoleContainer indicates an expected call of ConsoleContainer
func (mr *MockContainerServerMockRecorder) ConsoleContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsoleContainer", reflect.TypeOf((*MockContainerServer)(nil).ConsoleContainer), arg0, arg1, arg2)
}

// CopyContainer mocks base method
func (m *MockContainerServer) CopyContainer(arg0 client.ContainerServer, arg1 api.Container, arg2 *client.ContainerCopyArgs) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "CopyContainer", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyContainer indicates an expected call of CopyContainer
func (mr *MockContainerServerMockRecorder) CopyContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyContainer", reflect.TypeOf((*MockContainerServer)(nil).CopyContainer), arg0, arg1, arg2)
}

// CopyContainerSnapshot mocks base method
func (m *MockContainerServer) CopyContainerSnapshot(arg0 client.ContainerServer, arg1 string, arg2 api.ContainerSnapshot, arg3 *client.ContainerSnapshotCopyArgs) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "CopyContainerSnapshot", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyContainerSnapshot indicates an expected call of CopyContainerSnapshot
func (mr *MockContainerServerMockRecorder) CopyContainerSnapshot(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).CopyContainerSnapshot), arg0, arg1, arg2, arg3)
}

// CopyImage mocks base method
func (m *MockContainerServer) CopyImage(arg0 client.ImageServer, arg1 api.Image, arg2 *client.ImageCopyArgs) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "CopyImage", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyImage indicates an expected call of CopyImage
func (mr *MockContainerServerMockRecorder) CopyImage(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockContainerServer)(nil).CopyImage), arg0, arg1, arg2)
}

// CopyStoragePoolVolume mocks base method
func (m *MockContainerServer) CopyStoragePoolVolume(arg0 string, arg1 client.ContainerServer, arg2 string, arg3 api.StorageVolume, arg4 *client.StoragePoolVolumeCopyArgs) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "CopyStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyStoragePoolVolume indicates an expected call of CopyStoragePoolVolume
func (mr *MockContainerServerMockRecorder) CopyStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).CopyStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
}

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

// CreateCertificate indicates an expected call of CreateCertificate
func (mr *MockContainerServerMockRecorder) CreateCertificate(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockContainerServer)(nil).CreateCertificate), arg0)
}

// CreateContainer mocks base method
func (m *MockContainerServer) CreateContainer(arg0 api.ContainersPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateContainer", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainer indicates an expected call of CreateContainer
func (mr *MockContainerServerMockRecorder) CreateContainer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockContainerServer)(nil).CreateContainer), arg0)
}

// CreateContainerBackup mocks base method
func (m *MockContainerServer) CreateContainerBackup(arg0 string, arg1 api.ContainerBackupsPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateContainerBackup", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerBackup indicates an expected call of CreateContainerBackup
func (mr *MockContainerServerMockRecorder) CreateContainerBackup(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerBackup", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerBackup), arg0, arg1)
}

// CreateContainerFile mocks base method
func (m *MockContainerServer) CreateContainerFile(arg0, arg1 string, arg2 client.ContainerFileArgs) error {
	ret := m.ctrl.Call(m, "CreateContainerFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateContainerFile indicates an expected call of CreateContainerFile
func (mr *MockContainerServerMockRecorder) CreateContainerFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFile", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerFile), arg0, arg1, arg2)
}

// CreateContainerFromBackup mocks base method
func (m *MockContainerServer) CreateContainerFromBackup(arg0 client.ContainerBackupArgs) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateContainerFromBackup", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerFromBackup indicates an expected call of CreateContainerFromBackup
func (mr *MockContainerServerMockRecorder) CreateContainerFromBackup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFromBackup", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerFromBackup), arg0)
}

// CreateContainerFromImage mocks base method
func (m *MockContainerServer) CreateContainerFromImage(arg0 client.ImageServer, arg1 api.Image, arg2 api.ContainersPost) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "CreateContainerFromImage", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerFromImage indicates an expected call of CreateContainerFromImage
func (mr *MockContainerServerMockRecorder) CreateContainerFromImage(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerFromImage", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerFromImage), arg0, arg1, arg2)
}

// CreateContainerSnapshot mocks base method
func (m *MockContainerServer) CreateContainerSnapshot(arg0 string, arg1 api.ContainerSnapshotsPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateContainerSnapshot", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainerSnapshot indicates an expected call of CreateContainerSnapshot
func (mr *MockContainerServerMockRecorder) CreateContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerSnapshot), arg0, arg1)
}

// CreateContainerTemplateFile mocks base method
func (m *MockContainerServer) CreateContainerTemplateFile(arg0, arg1 string, arg2 io.ReadSeeker) error {
	ret := m.ctrl.Call(m, "CreateContainerTemplateFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateContainerTemplateFile indicates an expected call of CreateContainerTemplateFile
func (mr *MockContainerServerMockRecorder) CreateContainerTemplateFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).CreateContainerTemplateFile), arg0, arg1, arg2)
}

// CreateImage mocks base method
func (m *MockContainerServer) CreateImage(arg0 api.ImagesPost, arg1 *client.ImageCreateArgs) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateImage", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateImage indicates an expected call of CreateImage
func (mr *MockContainerServerMockRecorder) CreateImage(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockContainerServer)(nil).CreateImage), arg0, arg1)
}

// CreateImageAlias mocks base method
func (m *MockContainerServer) CreateImageAlias(arg0 api.ImageAliasesPost) error {
	ret := m.ctrl.Call(m, "CreateImageAlias", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateImageAlias indicates an expected call of CreateImageAlias
func (mr *MockContainerServerMockRecorder) CreateImageAlias(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageAlias", reflect.TypeOf((*MockContainerServer)(nil).CreateImageAlias), arg0)
}

// CreateImageSecret mocks base method
func (m *MockContainerServer) CreateImageSecret(arg0 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateImageSecret", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateImageSecret indicates an expected call of CreateImageSecret
func (mr *MockContainerServerMockRecorder) CreateImageSecret(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageSecret", reflect.TypeOf((*MockContainerServer)(nil).CreateImageSecret), arg0)
}

// CreateNetwork mocks base method
func (m *MockContainerServer) CreateNetwork(arg0 api.NetworksPost) error {
	ret := m.ctrl.Call(m, "CreateNetwork", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNetwork indicates an expected call of CreateNetwork
func (mr *MockContainerServerMockRecorder) CreateNetwork(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetwork", reflect.TypeOf((*MockContainerServer)(nil).CreateNetwork), arg0)
}

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

// CreateProfile indicates an expected call of CreateProfile
func (mr *MockContainerServerMockRecorder) CreateProfile(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProfile", reflect.TypeOf((*MockContainerServer)(nil).CreateProfile), arg0)
}

// CreateProject mocks base method
func (m *MockContainerServer) CreateProject(arg0 api.ProjectsPost) error {
	ret := m.ctrl.Call(m, "CreateProject", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateProject indicates an expected call of CreateProject
func (mr *MockContainerServerMockRecorder) CreateProject(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockContainerServer)(nil).CreateProject), arg0)
}

// CreateStoragePool mocks base method
func (m *MockContainerServer) CreateStoragePool(arg0 api.StoragePoolsPost) error {
	ret := m.ctrl.Call(m, "CreateStoragePool", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateStoragePool indicates an expected call of CreateStoragePool
func (mr *MockContainerServerMockRecorder) CreateStoragePool(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoragePool", reflect.TypeOf((*MockContainerServer)(nil).CreateStoragePool), arg0)
}

// CreateStoragePoolVolume mocks base method
func (m *MockContainerServer) CreateStoragePoolVolume(arg0 string, arg1 api.StorageVolumesPost) error {
	ret := m.ctrl.Call(m, "CreateStoragePoolVolume", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateStoragePoolVolume indicates an expected call of CreateStoragePoolVolume
func (mr *MockContainerServerMockRecorder) CreateStoragePoolVolume(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).CreateStoragePoolVolume), arg0, arg1)
}

// CreateStoragePoolVolumeSnapshot mocks base method
func (m *MockContainerServer) CreateStoragePoolVolumeSnapshot(arg0, arg1, arg2 string, arg3 api.StorageVolumeSnapshotsPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "CreateStoragePoolVolumeSnapshot", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateStoragePoolVolumeSnapshot indicates an expected call of CreateStoragePoolVolumeSnapshot
func (mr *MockContainerServerMockRecorder) CreateStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoragePoolVolumeSnapshot", reflect.TypeOf((*MockContainerServer)(nil).CreateStoragePoolVolumeSnapshot), arg0, arg1, arg2, arg3)
}

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

// DeleteCertificate indicates an expected call of DeleteCertificate
func (mr *MockContainerServerMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockContainerServer)(nil).DeleteCertificate), arg0)
}

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

// DeleteClusterMember indicates an expected call of DeleteClusterMember
func (mr *MockContainerServerMockRecorder) DeleteClusterMember(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMember", reflect.TypeOf((*MockContainerServer)(nil).DeleteClusterMember), arg0, arg1)
}

// DeleteContainer mocks base method
func (m *MockContainerServer) DeleteContainer(arg0 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "DeleteContainer", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContainer indicates an expected call of DeleteContainer
func (mr *MockContainerServerMockRecorder) DeleteContainer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainer", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainer), arg0)
}

// DeleteContainerBackup mocks base method
func (m *MockContainerServer) DeleteContainerBackup(arg0, arg1 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "DeleteContainerBackup", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContainerBackup indicates an expected call of DeleteContainerBackup
func (mr *MockContainerServerMockRecorder) DeleteContainerBackup(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerBackup", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerBackup), arg0, arg1)
}

// DeleteContainerConsoleLog mocks base method
func (m *MockContainerServer) DeleteContainerConsoleLog(arg0 string, arg1 *client.ContainerConsoleLogArgs) error {
	ret := m.ctrl.Call(m, "DeleteContainerConsoleLog", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteContainerConsoleLog indicates an expected call of DeleteContainerConsoleLog
func (mr *MockContainerServerMockRecorder) DeleteContainerConsoleLog(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerConsoleLog", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerConsoleLog), arg0, arg1)
}

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

// DeleteContainerFile indicates an expected call of DeleteContainerFile
func (mr *MockContainerServerMockRecorder) DeleteContainerFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerFile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerFile), arg0, arg1)
}

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

// DeleteContainerLogfile indicates an expected call of DeleteContainerLogfile
func (mr *MockContainerServerMockRecorder) DeleteContainerLogfile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerLogfile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerLogfile), arg0, arg1)
}

// DeleteContainerSnapshot mocks base method
func (m *MockContainerServer) DeleteContainerSnapshot(arg0, arg1 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "DeleteContainerSnapshot", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContainerSnapshot indicates an expected call of DeleteContainerSnapshot
func (mr *MockContainerServerMockRecorder) DeleteContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerSnapshot), arg0, arg1)
}

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

// DeleteContainerTemplateFile indicates an expected call of DeleteContainerTemplateFile
func (mr *MockContainerServerMockRecorder) DeleteContainerTemplateFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).DeleteContainerTemplateFile), arg0, arg1)
}

// DeleteImage mocks base method
func (m *MockContainerServer) DeleteImage(arg0 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "DeleteImage", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteImage indicates an expected call of DeleteImage
func (mr *MockContainerServerMockRecorder) DeleteImage(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImage", reflect.TypeOf((*MockContainerServer)(nil).DeleteImage), arg0)
}

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

// DeleteImageAlias indicates an expected call of DeleteImageAlias
func (mr *MockContainerServerMockRecorder) DeleteImageAlias(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImageAlias", reflect.TypeOf((*MockContainerServer)(nil).DeleteImageAlias), arg0)
}

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

// DeleteNetwork indicates an expected call of DeleteNetwork
func (mr *MockContainerServerMockRecorder) DeleteNetwork(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetwork", reflect.TypeOf((*MockContainerServer)(nil).DeleteNetwork), arg0)
}

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

// DeleteOperation indicates an expected call of DeleteOperation
func (mr *MockContainerServerMockRecorder) DeleteOperation(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOperation", reflect.TypeOf((*MockContainerServer)(nil).DeleteOperation), arg0)
}

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

// DeleteProfile indicates an expected call of DeleteProfile
func (mr *MockContainerServerMockRecorder) DeleteProfile(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProfile", reflect.TypeOf((*MockContainerServer)(nil).DeleteProfile), arg0)
}

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

// DeleteProject indicates an expected call of DeleteProject
func (mr *MockContainerServerMockRecorder) DeleteProject(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProject", reflect.TypeOf((*MockContainerServer)(nil).DeleteProject), arg0)
}

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

// DeleteStoragePool indicates an expected call of DeleteStoragePool
func (mr *MockContainerServerMockRecorder) DeleteStoragePool(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePool", reflect.TypeOf((*MockContainerServer)(nil).DeleteStoragePool), arg0)
}

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

// DeleteStoragePoolVolume indicates an expected call of DeleteStoragePoolVolume
func (mr *MockContainerServerMockRecorder) DeleteStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).DeleteStoragePoolVolume), arg0, arg1, arg2)
}

// DeleteStoragePoolVolumeSnapshot mocks base method
func (m *MockContainerServer) DeleteStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "DeleteStoragePoolVolumeSnapshot", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteStoragePoolVolumeSnapshot indicates an expected call of DeleteStoragePoolVolumeSnapshot
func (mr *MockContainerServerMockRecorder) DeleteStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStoragePoolVolumeSnapshot", reflect.TypeOf((*MockContainerServer)(nil).DeleteStoragePoolVolumeSnapshot), arg0, arg1, arg2, arg3)
}

// ExecContainer mocks base method
func (m *MockContainerServer) ExecContainer(arg0 string, arg1 api.ContainerExecPost, arg2 *client.ContainerExecArgs) (client.Operation, error) {
	ret := m.ctrl.Call(m, "ExecContainer", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecContainer indicates an expected call of ExecContainer
func (mr *MockContainerServerMockRecorder) ExecContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecContainer", reflect.TypeOf((*MockContainerServer)(nil).ExecContainer), arg0, arg1, arg2)
}

// GetCertificate mocks base method
func (m *MockContainerServer) GetCertificate(arg0 string) (*api.Certificate, string, error) {
	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 *MockContainerServerMockRecorder) GetCertificate(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockContainerServer)(nil).GetCertificate), arg0)
}

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

// GetCertificateFingerprints indicates an expected call of GetCertificateFingerprints
func (mr *MockContainerServerMockRecorder) GetCertificateFingerprints() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateFingerprints", reflect.TypeOf((*MockContainerServer)(nil).GetCertificateFingerprints))
}

// GetCertificates mocks base method
func (m *MockContainerServer) GetCertificates() ([]api.Certificate, error) {
	ret := m.ctrl.Call(m, "GetCertificates")
	ret0, _ := ret[0].([]api.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCertificates indicates an expected call of GetCertificates
func (mr *MockContainerServerMockRecorder) GetCertificates() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificates", reflect.TypeOf((*MockContainerServer)(nil).GetCertificates))
}

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

// GetCluster indicates an expected call of GetCluster
func (mr *MockContainerServerMockRecorder) GetCluster() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockContainerServer)(nil).GetCluster))
}

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

// GetClusterMember indicates an expected call of GetClusterMember
func (mr *MockContainerServerMockRecorder) GetClusterMember(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMember", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMember), arg0)
}

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

// GetClusterMemberNames indicates an expected call of GetClusterMemberNames
func (mr *MockContainerServerMockRecorder) GetClusterMemberNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMemberNames", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMemberNames))
}

// GetClusterMembers mocks base method
func (m *MockContainerServer) GetClusterMembers() ([]api.ClusterMember, error) {
	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 *MockContainerServerMockRecorder) GetClusterMembers() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockContainerServer)(nil).GetClusterMembers))
}

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

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

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

// GetContainer indicates an expected call of GetContainer
func (mr *MockContainerServerMockRecorder) GetContainer(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainer", reflect.TypeOf((*MockContainerServer)(nil).GetContainer), arg0)
}

// GetContainerBackup mocks base method
func (m *MockContainerServer) GetContainerBackup(arg0, arg1 string) (*api.ContainerBackup, string, error) {
	ret := m.ctrl.Call(m, "GetContainerBackup", arg0, arg1)
	ret0, _ := ret[0].(*api.ContainerBackup)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainerBackup indicates an expected call of GetContainerBackup
func (mr *MockContainerServerMockRecorder) GetContainerBackup(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerBackup", reflect.TypeOf((*MockContainerServer)(nil).GetContainerBackup), arg0, arg1)
}

// GetContainerBackupFile mocks base method
func (m *MockContainerServer) GetContainerBackupFile(arg0, arg1 string, arg2 *client.BackupFileRequest) (*client.BackupFileResponse, error) {
	ret := m.ctrl.Call(m, "GetContainerBackupFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(*client.BackupFileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerBackupFile indicates an expected call of GetContainerBackupFile
func (mr *MockContainerServerMockRecorder) GetContainerBackupFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerBackupFile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerBackupFile), arg0, arg1, arg2)
}

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

// GetContainerBackupNames indicates an expected call of GetContainerBackupNames
func (mr *MockContainerServerMockRecorder) GetContainerBackupNames(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerBackupNames", reflect.TypeOf((*MockContainerServer)(nil).GetContainerBackupNames), arg0)
}

// GetContainerBackups mocks base method
func (m *MockContainerServer) GetContainerBackups(arg0 string) ([]api.ContainerBackup, error) {
	ret := m.ctrl.Call(m, "GetContainerBackups", arg0)
	ret0, _ := ret[0].([]api.ContainerBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerBackups indicates an expected call of GetContainerBackups
func (mr *MockContainerServerMockRecorder) GetContainerBackups(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerBackups", reflect.TypeOf((*MockContainerServer)(nil).GetContainerBackups), arg0)
}

// GetContainerConsoleLog mocks base method
func (m *MockContainerServer) GetContainerConsoleLog(arg0 string, arg1 *client.ContainerConsoleLogArgs) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "GetContainerConsoleLog", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerConsoleLog indicates an expected call of GetContainerConsoleLog
func (mr *MockContainerServerMockRecorder) GetContainerConsoleLog(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerConsoleLog", reflect.TypeOf((*MockContainerServer)(nil).GetContainerConsoleLog), arg0, arg1)
}

// GetContainerFile mocks base method
func (m *MockContainerServer) GetContainerFile(arg0, arg1 string) (io.ReadCloser, *client.ContainerFileResponse, error) {
	ret := m.ctrl.Call(m, "GetContainerFile", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(*client.ContainerFileResponse)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainerFile indicates an expected call of GetContainerFile
func (mr *MockContainerServerMockRecorder) GetContainerFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerFile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerFile), arg0, arg1)
}

// GetContainerLogfile mocks base method
func (m *MockContainerServer) GetContainerLogfile(arg0, arg1 string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "GetContainerLogfile", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerLogfile indicates an expected call of GetContainerLogfile
func (mr *MockContainerServerMockRecorder) GetContainerLogfile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogfile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerLogfile), arg0, arg1)
}

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

// GetContainerLogfiles indicates an expected call of GetContainerLogfiles
func (mr *MockContainerServerMockRecorder) GetContainerLogfiles(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogfiles", reflect.TypeOf((*MockContainerServer)(nil).GetContainerLogfiles), arg0)
}

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

// GetContainerMetadata indicates an expected call of GetContainerMetadata
func (mr *MockContainerServerMockRecorder) GetContainerMetadata(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerMetadata", reflect.TypeOf((*MockContainerServer)(nil).GetContainerMetadata), arg0)
}

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

// GetContainerNames indicates an expected call of GetContainerNames
func (mr *MockContainerServerMockRecorder) GetContainerNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerNames", reflect.TypeOf((*MockContainerServer)(nil).GetContainerNames))
}

// GetContainerSnapshot mocks base method
func (m *MockContainerServer) GetContainerSnapshot(arg0, arg1 string) (*api.ContainerSnapshot, string, error) {
	ret := m.ctrl.Call(m, "GetContainerSnapshot", arg0, arg1)
	ret0, _ := ret[0].(*api.ContainerSnapshot)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainerSnapshot indicates an expected call of GetContainerSnapshot
func (mr *MockContainerServerMockRecorder) GetContainerSnapshot(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshot), arg0, arg1)
}

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

// GetContainerSnapshotNames indicates an expected call of GetContainerSnapshotNames
func (mr *MockContainerServerMockRecorder) GetContainerSnapshotNames(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshotNames", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshotNames), arg0)
}

// GetContainerSnapshots mocks base method
func (m *MockContainerServer) GetContainerSnapshots(arg0 string) ([]api.ContainerSnapshot, error) {
	ret := m.ctrl.Call(m, "GetContainerSnapshots", arg0)
	ret0, _ := ret[0].([]api.ContainerSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerSnapshots indicates an expected call of GetContainerSnapshots
func (mr *MockContainerServerMockRecorder) GetContainerSnapshots(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerSnapshots", reflect.TypeOf((*MockContainerServer)(nil).GetContainerSnapshots), arg0)
}

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

// GetContainerState indicates an expected call of GetContainerState
func (mr *MockContainerServerMockRecorder) GetContainerState(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerState", reflect.TypeOf((*MockContainerServer)(nil).GetContainerState), arg0)
}

// GetContainerTemplateFile mocks base method
func (m *MockContainerServer) GetContainerTemplateFile(arg0, arg1 string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "GetContainerTemplateFile", arg0, arg1)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerTemplateFile indicates an expected call of GetContainerTemplateFile
func (mr *MockContainerServerMockRecorder) GetContainerTemplateFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).GetContainerTemplateFile), arg0, arg1)
}

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

// GetContainerTemplateFiles indicates an expected call of GetContainerTemplateFiles
func (mr *MockContainerServerMockRecorder) GetContainerTemplateFiles(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerTemplateFiles", reflect.TypeOf((*MockContainerServer)(nil).GetContainerTemplateFiles), arg0)
}

// GetContainers mocks base method
func (m *MockContainerServer) GetContainers() ([]api.Container, error) {
	ret := m.ctrl.Call(m, "GetContainers")
	ret0, _ := ret[0].([]api.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainers indicates an expected call of GetContainers
func (mr *MockContainerServerMockRecorder) GetContainers() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainers", reflect.TypeOf((*MockContainerServer)(nil).GetContainers))
}

// GetContainersFull mocks base method
func (m *MockContainerServer) GetContainersFull() ([]api.ContainerFull, error) {
	ret := m.ctrl.Call(m, "GetContainersFull")
	ret0, _ := ret[0].([]api.ContainerFull)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainersFull indicates an expected call of GetContainersFull
func (mr *MockContainerServerMockRecorder) GetContainersFull() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainersFull", reflect.TypeOf((*MockContainerServer)(nil).GetContainersFull))
}

// GetEvents mocks base method
func (m *MockContainerServer) GetEvents() (*client.EventListener, error) {
	ret := m.ctrl.Call(m, "GetEvents")
	ret0, _ := ret[0].(*client.EventListener)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEvents indicates an expected call of GetEvents
func (mr *MockContainerServerMockRecorder) GetEvents() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvents", reflect.TypeOf((*MockContainerServer)(nil).GetEvents))
}

// GetHTTPClient mocks base method
func (m *MockContainerServer) GetHTTPClient() (*http.Client, error) {
	ret := m.ctrl.Call(m, "GetHTTPClient")
	ret0, _ := ret[0].(*http.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHTTPClient indicates an expected call of GetHTTPClient
func (mr *MockContainerServerMockRecorder) GetHTTPClient() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockContainerServer)(nil).GetHTTPClient))
}

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

// GetImage indicates an expected call of GetImage
func (mr *MockContainerServerMockRecorder) GetImage(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImage", reflect.TypeOf((*MockContainerServer)(nil).GetImage), arg0)
}

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

// GetImageAlias indicates an expected call of GetImageAlias
func (mr *MockContainerServerMockRecorder) GetImageAlias(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAlias", reflect.TypeOf((*MockContainerServer)(nil).GetImageAlias), arg0)
}

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

// GetImageAliasNames indicates an expected call of GetImageAliasNames
func (mr *MockContainerServerMockRecorder) GetImageAliasNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliasNames", reflect.TypeOf((*MockContainerServer)(nil).GetImageAliasNames))
}

// GetImageAliases mocks base method
func (m *MockContainerServer) GetImageAliases() ([]api.ImageAliasesEntry, error) {
	ret := m.ctrl.Call(m, "GetImageAliases")
	ret0, _ := ret[0].([]api.ImageAliasesEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageAliases indicates an expected call of GetImageAliases
func (mr *MockContainerServerMockRecorder) GetImageAliases() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageAliases", reflect.TypeOf((*MockContainerServer)(nil).GetImageAliases))
}

// GetImageFile mocks base method
func (m *MockContainerServer) GetImageFile(arg0 string, arg1 client.ImageFileRequest) (*client.ImageFileResponse, error) {
	ret := m.ctrl.Call(m, "GetImageFile", arg0, arg1)
	ret0, _ := ret[0].(*client.ImageFileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageFile indicates an expected call of GetImageFile
func (mr *MockContainerServerMockRecorder) GetImageFile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFile", reflect.TypeOf((*MockContainerServer)(nil).GetImageFile), arg0, arg1)
}

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

// GetImageFingerprints indicates an expected call of GetImageFingerprints
func (mr *MockContainerServerMockRecorder) GetImageFingerprints() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageFingerprints", reflect.TypeOf((*MockContainerServer)(nil).GetImageFingerprints))
}

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

// GetImageSecret indicates an expected call of GetImageSecret
func (mr *MockContainerServerMockRecorder) GetImageSecret(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageSecret", reflect.TypeOf((*MockContainerServer)(nil).GetImageSecret), arg0)
}

// GetImages mocks base method
func (m *MockContainerServer) GetImages() ([]api.Image, error) {
	ret := m.ctrl.Call(m, "GetImages")
	ret0, _ := ret[0].([]api.Image)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImages indicates an expected call of GetImages
func (mr *MockContainerServerMockRecorder) GetImages() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImages", reflect.TypeOf((*MockContainerServer)(nil).GetImages))
}

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

// GetNetwork indicates an expected call of GetNetwork
func (mr *MockContainerServerMockRecorder) GetNetwork(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetwork", reflect.TypeOf((*MockContainerServer)(nil).GetNetwork), arg0)
}

// GetNetworkLeases mocks base method
func (m *MockContainerServer) GetNetworkLeases(arg0 string) ([]api.NetworkLease, error) {
	ret := m.ctrl.Call(m, "GetNetworkLeases", arg0)
	ret0, _ := ret[0].([]api.NetworkLease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNetworkLeases indicates an expected call of GetNetworkLeases
func (mr *MockContainerServerMockRecorder) GetNetworkLeases(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkLeases", reflect.TypeOf((*MockContainerServer)(nil).GetNetworkLeases), arg0)
}

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

// GetNetworkNames indicates an expected call of GetNetworkNames
func (mr *MockContainerServerMockRecorder) GetNetworkNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkNames", reflect.TypeOf((*MockContainerServer)(nil).GetNetworkNames))
}

// GetNetworkState mocks base method
func (m *MockContainerServer) GetNetworkState(arg0 string) (*api.NetworkState, error) {
	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 *MockContainerServerMockRecorder) GetNetworkState(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkState", reflect.TypeOf((*MockContainerServer)(nil).GetNetworkState), arg0)
}

// GetNetworks mocks base method
func (m *MockContainerServer) GetNetworks() ([]api.Network, error) {
	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 *MockContainerServerMockRecorder) GetNetworks() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworks", reflect.TypeOf((*MockContainerServer)(nil).GetNetworks))
}

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

// GetOperation indicates an expected call of GetOperation
func (mr *MockContainerServerMockRecorder) GetOperation(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperation", reflect.TypeOf((*MockContainerServer)(nil).GetOperation), arg0)
}

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

// GetOperationUUIDs indicates an expected call of GetOperationUUIDs
func (mr *MockContainerServerMockRecorder) GetOperationUUIDs() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperationUUIDs", reflect.TypeOf((*MockContainerServer)(nil).GetOperationUUIDs))
}

// GetOperationWait mocks base method
func (m *MockContainerServer) GetOperationWait(arg0 string, arg1 int) (*api.Operation, string, error) {
	ret := m.ctrl.Call(m, "GetOperationWait", arg0, arg1)
	ret0, _ := ret[0].(*api.Operation)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetOperationWait indicates an expected call of GetOperationWait
func (mr *MockContainerServerMockRecorder) GetOperationWait(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperationWait", reflect.TypeOf((*MockContainerServer)(nil).GetOperationWait), arg0, arg1)
}

// GetOperationWebsocket mocks base method
func (m *MockContainerServer) GetOperationWebsocket(arg0, arg1 string) (*websocket.Conn, error) {
	ret := m.ctrl.Call(m, "GetOperationWebsocket", arg0, arg1)
	ret0, _ := ret[0].(*websocket.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperationWebsocket indicates an expected call of GetOperationWebsocket
func (mr *MockContainerServerMockRecorder) GetOperationWebsocket(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperationWebsocket", reflect.TypeOf((*MockContainerServer)(nil).GetOperationWebsocket), arg0, arg1)
}

// GetOperations mocks base method
func (m *MockContainerServer) GetOperations() ([]api.Operation, error) {
	ret := m.ctrl.Call(m, "GetOperations")
	ret0, _ := ret[0].([]api.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperations indicates an expected call of GetOperations
func (mr *MockContainerServerMockRecorder) GetOperations() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperations", reflect.TypeOf((*MockContainerServer)(nil).GetOperations))
}

// GetPrivateImage mocks base method
func (m *MockContainerServer) GetPrivateImage(arg0, arg1 string) (*api.Image, string, error) {
	ret := m.ctrl.Call(m, "GetPrivateImage", arg0, arg1)
	ret0, _ := ret[0].(*api.Image)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPrivateImage indicates an expected call of GetPrivateImage
func (mr *MockContainerServerMockRecorder) GetPrivateImage(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImage", reflect.TypeOf((*MockContainerServer)(nil).GetPrivateImage), arg0, arg1)
}

// GetPrivateImageFile mocks base method
func (m *MockContainerServer) GetPrivateImageFile(arg0, arg1 string, arg2 client.ImageFileRequest) (*client.ImageFileResponse, error) {
	ret := m.ctrl.Call(m, "GetPrivateImageFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(*client.ImageFileResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrivateImageFile indicates an expected call of GetPrivateImageFile
func (mr *MockContainerServerMockRecorder) GetPrivateImageFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivateImageFile", reflect.TypeOf((*MockContainerServer)(nil).GetPrivateImageFile), arg0, arg1, arg2)
}

// GetProfile mocks base method
func (m *MockContainerServer) GetProfile(arg0 string) (*api.Profile, string, error) {
	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 *MockContainerServerMockRecorder) GetProfile(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfile", reflect.TypeOf((*MockContainerServer)(nil).GetProfile), arg0)
}

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

// GetProfileNames indicates an expected call of GetProfileNames
func (mr *MockContainerServerMockRecorder) GetProfileNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfileNames", reflect.TypeOf((*MockContainerServer)(nil).GetProfileNames))
}

// GetProfiles mocks base method
func (m *MockContainerServer) GetProfiles() ([]api.Profile, error) {
	ret := m.ctrl.Call(m, "GetProfiles")
	ret0, _ := ret[0].([]api.Profile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProfiles indicates an expected call of GetProfiles
func (mr *MockContainerServerMockRecorder) GetProfiles() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProfiles", reflect.TypeOf((*MockContainerServer)(nil).GetProfiles))
}

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

// GetProject indicates an expected call of GetProject
func (mr *MockContainerServerMockRecorder) GetProject(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProject", reflect.TypeOf((*MockContainerServer)(nil).GetProject), arg0)
}

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

// GetProjectNames indicates an expected call of GetProjectNames
func (mr *MockContainerServerMockRecorder) GetProjectNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectNames", reflect.TypeOf((*MockContainerServer)(nil).GetProjectNames))
}

// GetProjects mocks base method
func (m *MockContainerServer) GetProjects() ([]api.Project, error) {
	ret := m.ctrl.Call(m, "GetProjects")
	ret0, _ := ret[0].([]api.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjects indicates an expected call of GetProjects
func (mr *MockContainerServerMockRecorder) GetProjects() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjects", reflect.TypeOf((*MockContainerServer)(nil).GetProjects))
}

// GetServer mocks base method
func (m *MockContainerServer) GetServer() (*api.Server, string, error) {
	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 *MockContainerServerMockRecorder) GetServer() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServer", reflect.TypeOf((*MockContainerServer)(nil).GetServer))
}

// GetServerResources mocks base method
func (m *MockContainerServer) GetServerResources() (*api.Resources, error) {
	ret := m.ctrl.Call(m, "GetServerResources")
	ret0, _ := ret[0].(*api.Resources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerResources indicates an expected call of GetServerResources
func (mr *MockContainerServerMockRecorder) GetServerResources() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerResources", reflect.TypeOf((*MockContainerServer)(nil).GetServerResources))
}

// GetStoragePool mocks base method
func (m *MockContainerServer) GetStoragePool(arg0 string) (*api.StoragePool, string, error) {
	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 *MockContainerServerMockRecorder) GetStoragePool(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePool", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePool), arg0)
}

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

// GetStoragePoolNames indicates an expected call of GetStoragePoolNames
func (mr *MockContainerServerMockRecorder) GetStoragePoolNames() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolNames", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolNames))
}

// GetStoragePoolResources mocks base method
func (m *MockContainerServer) GetStoragePoolResources(arg0 string) (*api.ResourcesStoragePool, error) {
	ret := m.ctrl.Call(m, "GetStoragePoolResources", arg0)
	ret0, _ := ret[0].(*api.ResourcesStoragePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStoragePoolResources indicates an expected call of GetStoragePoolResources
func (mr *MockContainerServerMockRecorder) GetStoragePoolResources(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolResources", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolResources), arg0)
}

// GetStoragePoolVolume mocks base method
func (m *MockContainerServer) GetStoragePoolVolume(arg0, arg1, arg2 string) (*api.StorageVolume, string, error) {
	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 *MockContainerServerMockRecorder) GetStoragePoolVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolume), arg0, arg1, arg2)
}

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

// GetStoragePoolVolumeNames indicates an expected call of GetStoragePoolVolumeNames
func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumeNames(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumeNames", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumeNames), arg0)
}

// GetStoragePoolVolumeSnapshot mocks base method
func (m *MockContainerServer) GetStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 string) (*api.StorageVolumeSnapshot, string, error) {
	ret := m.ctrl.Call(m, "GetStoragePoolVolumeSnapshot", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*api.StorageVolumeSnapshot)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetStoragePoolVolumeSnapshot indicates an expected call of GetStoragePoolVolumeSnapshot
func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumeSnapshot", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumeSnapshot), arg0, arg1, arg2, arg3)
}

// GetStoragePoolVolumeSnapshotNames mocks base method
func (m *MockContainerServer) GetStoragePoolVolumeSnapshotNames(arg0, arg1, arg2 string) ([]string, error) {
	ret := m.ctrl.Call(m, "GetStoragePoolVolumeSnapshotNames", arg0, arg1, arg2)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStoragePoolVolumeSnapshotNames indicates an expected call of GetStoragePoolVolumeSnapshotNames
func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumeSnapshotNames(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumeSnapshotNames", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumeSnapshotNames), arg0, arg1, arg2)
}

// GetStoragePoolVolumeSnapshots mocks base method
func (m *MockContainerServer) GetStoragePoolVolumeSnapshots(arg0, arg1, arg2 string) ([]api.StorageVolumeSnapshot, error) {
	ret := m.ctrl.Call(m, "GetStoragePoolVolumeSnapshots", arg0, arg1, arg2)
	ret0, _ := ret[0].([]api.StorageVolumeSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStoragePoolVolumeSnapshots indicates an expected call of GetStoragePoolVolumeSnapshots
func (mr *MockContainerServerMockRecorder) GetStoragePoolVolumeSnapshots(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumeSnapshots", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumeSnapshots), arg0, arg1, arg2)
}

// GetStoragePoolVolumes mocks base method
func (m *MockContainerServer) GetStoragePoolVolumes(arg0 string) ([]api.StorageVolume, error) {
	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 *MockContainerServerMockRecorder) GetStoragePoolVolumes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolVolumes", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePoolVolumes), arg0)
}

// GetStoragePools mocks base method
func (m *MockContainerServer) GetStoragePools() ([]api.StoragePool, error) {
	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 *MockContainerServerMockRecorder) GetStoragePools() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePools", reflect.TypeOf((*MockContainerServer)(nil).GetStoragePools))
}

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

// HasExtension indicates an expected call of HasExtension
func (mr *MockContainerServerMockRecorder) HasExtension(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasExtension", reflect.TypeOf((*MockContainerServer)(nil).HasExtension), arg0)
}

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

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

// MigrateContainer mocks base method
func (m *MockContainerServer) MigrateContainer(arg0 string, arg1 api.ContainerPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "MigrateContainer", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateContainer indicates an expected call of MigrateContainer
func (mr *MockContainerServerMockRecorder) MigrateContainer(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateContainer", reflect.TypeOf((*MockContainerServer)(nil).MigrateContainer), arg0, arg1)
}

// MigrateContainerSnapshot mocks base method
func (m *MockContainerServer) MigrateContainerSnapshot(arg0, arg1 string, arg2 api.ContainerSnapshotPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "MigrateContainerSnapshot", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateContainerSnapshot indicates an expected call of MigrateContainerSnapshot
func (mr *MockContainerServerMockRecorder) MigrateContainerSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).MigrateContainerSnapshot), arg0, arg1, arg2)
}

// MigrateStoragePoolVolume mocks base method
func (m *MockContainerServer) MigrateStoragePoolVolume(arg0 string, arg1 api.StorageVolumePost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "MigrateStoragePoolVolume", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MigrateStoragePoolVolume indicates an expected call of MigrateStoragePoolVolume
func (mr *MockContainerServerMockRecorder) MigrateStoragePoolVolume(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).MigrateStoragePoolVolume), arg0, arg1)
}

// MoveStoragePoolVolume mocks base method
func (m *MockContainerServer) MoveStoragePoolVolume(arg0 string, arg1 client.ContainerServer, arg2 string, arg3 api.StorageVolume, arg4 *client.StoragePoolVolumeMoveArgs) (client.RemoteOperation, error) {
	ret := m.ctrl.Call(m, "MoveStoragePoolVolume", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(client.RemoteOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MoveStoragePoolVolume indicates an expected call of MoveStoragePoolVolume
func (mr *MockContainerServerMockRecorder) MoveStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).MoveStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
}

// RawOperation mocks base method
func (m *MockContainerServer) RawOperation(arg0, arg1 string, arg2 interface{}, arg3 string) (client.Operation, string, error) {
	ret := m.ctrl.Call(m, "RawOperation", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RawOperation indicates an expected call of RawOperation
func (mr *MockContainerServerMockRecorder) RawOperation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawOperation", reflect.TypeOf((*MockContainerServer)(nil).RawOperation), arg0, arg1, arg2, arg3)
}

// RawQuery mocks base method
func (m *MockContainerServer) RawQuery(arg0, arg1 string, arg2 interface{}, arg3 string) (*api.Response, string, error) {
	ret := m.ctrl.Call(m, "RawQuery", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*api.Response)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RawQuery indicates an expected call of RawQuery
func (mr *MockContainerServerMockRecorder) RawQuery(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawQuery", reflect.TypeOf((*MockContainerServer)(nil).RawQuery), arg0, arg1, arg2, arg3)
}

// RawWebsocket mocks base method
func (m *MockContainerServer) RawWebsocket(arg0 string) (*websocket.Conn, error) {
	ret := m.ctrl.Call(m, "RawWebsocket", arg0)
	ret0, _ := ret[0].(*websocket.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RawWebsocket indicates an expected call of RawWebsocket
func (mr *MockContainerServerMockRecorder) RawWebsocket(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawWebsocket", reflect.TypeOf((*MockContainerServer)(nil).RawWebsocket), arg0)
}

// RefreshImage mocks base method
func (m *MockContainerServer) RefreshImage(arg0 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RefreshImage", arg0)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RefreshImage indicates an expected call of RefreshImage
func (mr *MockContainerServerMockRecorder) RefreshImage(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshImage", reflect.TypeOf((*MockContainerServer)(nil).RefreshImage), arg0)
}

// RenameClusterMember mocks base method
func (m *MockContainerServer) RenameClusterMember(arg0 string, arg1 api.ClusterMemberPost) error {
	ret := m.ctrl.Call(m, "RenameClusterMember", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameClusterMember indicates an expected call of RenameClusterMember
func (mr *MockContainerServerMockRecorder) RenameClusterMember(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameClusterMember", reflect.TypeOf((*MockContainerServer)(nil).RenameClusterMember), arg0, arg1)
}

// RenameContainer mocks base method
func (m *MockContainerServer) RenameContainer(arg0 string, arg1 api.ContainerPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RenameContainer", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenameContainer indicates an expected call of RenameContainer
func (mr *MockContainerServerMockRecorder) RenameContainer(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameContainer", reflect.TypeOf((*MockContainerServer)(nil).RenameContainer), arg0, arg1)
}

// RenameContainerBackup mocks base method
func (m *MockContainerServer) RenameContainerBackup(arg0, arg1 string, arg2 api.ContainerBackupPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RenameContainerBackup", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenameContainerBackup indicates an expected call of RenameContainerBackup
func (mr *MockContainerServerMockRecorder) RenameContainerBackup(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameContainerBackup", reflect.TypeOf((*MockContainerServer)(nil).RenameContainerBackup), arg0, arg1, arg2)
}

// RenameContainerSnapshot mocks base method
func (m *MockContainerServer) RenameContainerSnapshot(arg0, arg1 string, arg2 api.ContainerSnapshotPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RenameContainerSnapshot", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenameContainerSnapshot indicates an expected call of RenameContainerSnapshot
func (mr *MockContainerServerMockRecorder) RenameContainerSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameContainerSnapshot", reflect.TypeOf((*MockContainerServer)(nil).RenameContainerSnapshot), arg0, arg1, arg2)
}

// RenameImageAlias mocks base method
func (m *MockContainerServer) RenameImageAlias(arg0 string, arg1 api.ImageAliasesEntryPost) error {
	ret := m.ctrl.Call(m, "RenameImageAlias", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameImageAlias indicates an expected call of RenameImageAlias
func (mr *MockContainerServerMockRecorder) RenameImageAlias(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameImageAlias", reflect.TypeOf((*MockContainerServer)(nil).RenameImageAlias), arg0, arg1)
}

// RenameNetwork mocks base method
func (m *MockContainerServer) RenameNetwork(arg0 string, arg1 api.NetworkPost) error {
	ret := m.ctrl.Call(m, "RenameNetwork", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameNetwork indicates an expected call of RenameNetwork
func (mr *MockContainerServerMockRecorder) RenameNetwork(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNetwork", reflect.TypeOf((*MockContainerServer)(nil).RenameNetwork), arg0, arg1)
}

// RenameProfile mocks base method
func (m *MockContainerServer) RenameProfile(arg0 string, arg1 api.ProfilePost) error {
	ret := m.ctrl.Call(m, "RenameProfile", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameProfile indicates an expected call of RenameProfile
func (mr *MockContainerServerMockRecorder) RenameProfile(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameProfile", reflect.TypeOf((*MockContainerServer)(nil).RenameProfile), arg0, arg1)
}

// RenameProject mocks base method
func (m *MockContainerServer) RenameProject(arg0 string, arg1 api.ProjectPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RenameProject", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenameProject indicates an expected call of RenameProject
func (mr *MockContainerServerMockRecorder) RenameProject(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameProject", reflect.TypeOf((*MockContainerServer)(nil).RenameProject), arg0, arg1)
}

// RenameStoragePoolVolume mocks base method
func (m *MockContainerServer) RenameStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePost) error {
	ret := m.ctrl.Call(m, "RenameStoragePoolVolume", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameStoragePoolVolume indicates an expected call of RenameStoragePoolVolume
func (mr *MockContainerServerMockRecorder) RenameStoragePoolVolume(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).RenameStoragePoolVolume), arg0, arg1, arg2, arg3)
}

// RenameStoragePoolVolumeSnapshot mocks base method
func (m *MockContainerServer) RenameStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 string, arg4 api.StorageVolumeSnapshotPost) (client.Operation, error) {
	ret := m.ctrl.Call(m, "RenameStoragePoolVolumeSnapshot", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RenameStoragePoolVolumeSnapshot indicates an expected call of RenameStoragePoolVolumeSnapshot
func (mr *MockContainerServerMockRecorder) RenameStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameStoragePoolVolumeSnapshot", reflect.TypeOf((*MockContainerServer)(nil).RenameStoragePoolVolumeSnapshot), arg0, arg1, arg2, arg3, arg4)
}

// RequireAuthenticated mocks base method
func (m *MockContainerServer) RequireAuthenticated(arg0 bool) {
	m.ctrl.Call(m, "RequireAuthenticated", arg0)
}

// RequireAuthenticated indicates an expected call of RequireAuthenticated
func (mr *MockContainerServerMockRecorder) RequireAuthenticated(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequireAuthenticated", reflect.TypeOf((*MockContainerServer)(nil).RequireAuthenticated), arg0)
}

// SetContainerMetadata mocks base method
func (m *MockContainerServer) SetContainerMetadata(arg0 string, arg1 api.ImageMetadata, arg2 string) error {
	ret := m.ctrl.Call(m, "SetContainerMetadata", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetContainerMetadata indicates an expected call of SetContainerMetadata
func (mr *MockContainerServerMockRecorder) SetContainerMetadata(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContainerMetadata", reflect.TypeOf((*MockContainerServer)(nil).SetContainerMetadata), arg0, arg1, arg2)
}

// UpdateCertificate mocks base method
func (m *MockContainerServer) UpdateCertificate(arg0 string, arg1 api.CertificatePut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateCertificate", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCertificate indicates an expected call of UpdateCertificate
func (mr *MockContainerServerMockRecorder) UpdateCertificate(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificate", reflect.TypeOf((*MockContainerServer)(nil).UpdateCertificate), arg0, arg1, arg2)
}

// UpdateCluster mocks base method
func (m *MockContainerServer) UpdateCluster(arg0 api.ClusterPut, arg1 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "UpdateCluster", arg0, arg1)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster
func (mr *MockContainerServerMockRecorder) UpdateCluster(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockContainerServer)(nil).UpdateCluster), arg0, arg1)
}

// UpdateContainer mocks base method
func (m *MockContainerServer) UpdateContainer(arg0 string, arg1 api.ContainerPut, arg2 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "UpdateContainer", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainer indicates an expected call of UpdateContainer
func (mr *MockContainerServerMockRecorder) UpdateContainer(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainer", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainer), arg0, arg1, arg2)
}

// UpdateContainerState mocks base method
func (m *MockContainerServer) UpdateContainerState(arg0 string, arg1 api.ContainerStatePut, arg2 string) (client.Operation, error) {
	ret := m.ctrl.Call(m, "UpdateContainerState", arg0, arg1, arg2)
	ret0, _ := ret[0].(client.Operation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContainerState indicates an expected call of UpdateContainerState
func (mr *MockContainerServerMockRecorder) UpdateContainerState(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerState", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainerState), arg0, arg1, arg2)
}

// UpdateContainerTemplateFile mocks base method
func (m *MockContainerServer) UpdateContainerTemplateFile(arg0, arg1 string, arg2 io.ReadSeeker) error {
	ret := m.ctrl.Call(m, "UpdateContainerTemplateFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateContainerTemplateFile indicates an expected call of UpdateContainerTemplateFile
func (mr *MockContainerServerMockRecorder) UpdateContainerTemplateFile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContainerTemplateFile", reflect.TypeOf((*MockContainerServer)(nil).UpdateContainerTemplateFile), arg0, arg1, arg2)
}

// UpdateImage mocks base method
func (m *MockContainerServer) UpdateImage(arg0 string, arg1 api.ImagePut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateImage", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateImage indicates an expected call of UpdateImage
func (mr *MockContainerServerMockRecorder) UpdateImage(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImage", reflect.TypeOf((*MockContainerServer)(nil).UpdateImage), arg0, arg1, arg2)
}

// UpdateImageAlias mocks base method
func (m *MockContainerServer) UpdateImageAlias(arg0 string, arg1 api.ImageAliasesEntryPut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateImageAlias", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateImageAlias indicates an expected call of UpdateImageAlias
func (mr *MockContainerServerMockRecorder) UpdateImageAlias(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateImageAlias", reflect.TypeOf((*MockContainerServer)(nil).UpdateImageAlias), arg0, arg1, arg2)
}

// UpdateNetwork mocks base method
func (m *MockContainerServer) UpdateNetwork(arg0 string, arg1 api.NetworkPut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateNetwork", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateNetwork indicates an expected call of UpdateNetwork
func (mr *MockContainerServerMockRecorder) UpdateNetwork(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNetwork", reflect.TypeOf((*MockContainerServer)(nil).UpdateNetwork), arg0, arg1, arg2)
}

// UpdateProfile mocks base method
func (m *MockContainerServer) UpdateProfile(arg0 string, arg1 api.ProfilePut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateProfile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProfile indicates an expected call of UpdateProfile
func (mr *MockContainerServerMockRecorder) UpdateProfile(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProfile", reflect.TypeOf((*MockContainerServer)(nil).UpdateProfile), arg0, arg1, arg2)
}

// UpdateProject mocks base method
func (m *MockContainerServer) UpdateProject(arg0 string, arg1 api.ProjectPut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateProject", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProject indicates an expected call of UpdateProject
func (mr *MockContainerServerMockRecorder) UpdateProject(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockContainerServer)(nil).UpdateProject), arg0, arg1, arg2)
}

// UpdateServer mocks base method
func (m *MockContainerServer) UpdateServer(arg0 api.ServerPut, arg1 string) error {
	ret := m.ctrl.Call(m, "UpdateServer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateServer indicates an expected call of UpdateServer
func (mr *MockContainerServerMockRecorder) UpdateServer(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServer", reflect.TypeOf((*MockContainerServer)(nil).UpdateServer), arg0, arg1)
}

// UpdateStoragePool mocks base method
func (m *MockContainerServer) UpdateStoragePool(arg0 string, arg1 api.StoragePoolPut, arg2 string) error {
	ret := m.ctrl.Call(m, "UpdateStoragePool", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStoragePool indicates an expected call of UpdateStoragePool
func (mr *MockContainerServerMockRecorder) UpdateStoragePool(arg0, arg1, arg2 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePool", reflect.TypeOf((*MockContainerServer)(nil).UpdateStoragePool), arg0, arg1, arg2)
}

// UpdateStoragePoolVolume mocks base method
func (m *MockContainerServer) UpdateStoragePoolVolume(arg0, arg1, arg2 string, arg3 api.StorageVolumePut, arg4 string) error {
	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 *MockContainerServerMockRecorder) UpdateStoragePoolVolume(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePoolVolume", reflect.TypeOf((*MockContainerServer)(nil).UpdateStoragePoolVolume), arg0, arg1, arg2, arg3, arg4)
}

// UpdateStoragePoolVolumeSnapshot mocks base method
func (m *MockContainerServer) UpdateStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3 string, arg4 api.StorageVolumeSnapshotPut, arg5 string) error {
	ret := m.ctrl.Call(m, "UpdateStoragePoolVolumeSnapshot", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStoragePoolVolumeSnapshot indicates an expected call of UpdateStoragePoolVolumeSnapshot
func (mr *MockContainerServerMockRecorder) UpdateStoragePoolVolumeSnapshot(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStoragePoolVolumeSnapshot", reflect.TypeOf((*MockContainerServer)(nil).UpdateStoragePoolVolumeSnapshot), arg0, arg1, arg2, arg3, arg4, arg5)
}

// UseProject mocks base method
func (m *MockContainerServer) UseProject(arg0 string) client.ContainerServer {
	ret := m.ctrl.Call(m, "UseProject", arg0)
	ret0, _ := ret[0].(client.ContainerServer)
	return ret0
}

// UseProject indicates an expected call of UseProject
func (mr *MockContainerServerMockRecorder) UseProject(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseProject", reflect.TypeOf((*MockContainerServer)(nil).UseProject), arg0)
}

// UseTarget mocks base method
func (m *MockContainerServer) UseTarget(arg0 string) client.ContainerServer {
	ret := m.ctrl.Call(m, "UseTarget", arg0)
	ret0, _ := ret[0].(client.ContainerServer)
	return ret0
}

// UseTarget indicates an expected call of UseTarget
func (mr *MockContainerServerMockRecorder) UseTarget(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseTarget", reflect.TypeOf((*MockContainerServer)(nil).UseTarget), arg0)
}