// Code generated by counterfeiter. DO NOT EDIT.
package client

import (
	"io"
	"net"
	"net/http"
	"sync"

	"github.com/gorilla/websocket"
	lxd "github.com/lxc/lxd/client"
	"github.com/lxc/lxd/shared/api"
	"github.com/pkg/sftp"
)

type FakeContainerServer struct {
	ConsoleContainerStub        func(string, api.ContainerConsolePost, *lxd.ContainerConsoleArgs) (lxd.Operation, error)
	consoleContainerMutex       sync.RWMutex
	consoleContainerArgsForCall []struct {
		arg1 string
		arg2 api.ContainerConsolePost
		arg3 *lxd.ContainerConsoleArgs
	}
	consoleContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	consoleContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	ConsoleInstanceStub        func(string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) (lxd.Operation, error)
	consoleInstanceMutex       sync.RWMutex
	consoleInstanceArgsForCall []struct {
		arg1 string
		arg2 api.InstanceConsolePost
		arg3 *lxd.InstanceConsoleArgs
	}
	consoleInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	consoleInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	ConsoleInstanceDynamicStub        func(string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) (lxd.Operation, func(io.ReadWriteCloser) error, error)
	consoleInstanceDynamicMutex       sync.RWMutex
	consoleInstanceDynamicArgsForCall []struct {
		arg1 string
		arg2 api.InstanceConsolePost
		arg3 *lxd.InstanceConsoleArgs
	}
	consoleInstanceDynamicReturns struct {
		result1 lxd.Operation
		result2 func(io.ReadWriteCloser) error
		result3 error
	}
	consoleInstanceDynamicReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 func(io.ReadWriteCloser) error
		result3 error
	}
	CopyContainerStub        func(lxd.InstanceServer, api.Container, *lxd.ContainerCopyArgs) (lxd.RemoteOperation, error)
	copyContainerMutex       sync.RWMutex
	copyContainerArgsForCall []struct {
		arg1 lxd.InstanceServer
		arg2 api.Container
		arg3 *lxd.ContainerCopyArgs
	}
	copyContainerReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyContainerReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CopyContainerSnapshotStub        func(lxd.InstanceServer, string, api.ContainerSnapshot, *lxd.ContainerSnapshotCopyArgs) (lxd.RemoteOperation, error)
	copyContainerSnapshotMutex       sync.RWMutex
	copyContainerSnapshotArgsForCall []struct {
		arg1 lxd.InstanceServer
		arg2 string
		arg3 api.ContainerSnapshot
		arg4 *lxd.ContainerSnapshotCopyArgs
	}
	copyContainerSnapshotReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CopyImageStub        func(lxd.ImageServer, api.Image, *lxd.ImageCopyArgs) (lxd.RemoteOperation, error)
	copyImageMutex       sync.RWMutex
	copyImageArgsForCall []struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 *lxd.ImageCopyArgs
	}
	copyImageReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyImageReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CopyInstanceStub        func(lxd.InstanceServer, api.Instance, *lxd.InstanceCopyArgs) (lxd.RemoteOperation, error)
	copyInstanceMutex       sync.RWMutex
	copyInstanceArgsForCall []struct {
		arg1 lxd.InstanceServer
		arg2 api.Instance
		arg3 *lxd.InstanceCopyArgs
	}
	copyInstanceReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyInstanceReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CopyInstanceSnapshotStub        func(lxd.InstanceServer, string, api.InstanceSnapshot, *lxd.InstanceSnapshotCopyArgs) (lxd.RemoteOperation, error)
	copyInstanceSnapshotMutex       sync.RWMutex
	copyInstanceSnapshotArgsForCall []struct {
		arg1 lxd.InstanceServer
		arg2 string
		arg3 api.InstanceSnapshot
		arg4 *lxd.InstanceSnapshotCopyArgs
	}
	copyInstanceSnapshotReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CopyStoragePoolVolumeStub        func(string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeCopyArgs) (lxd.RemoteOperation, error)
	copyStoragePoolVolumeMutex       sync.RWMutex
	copyStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 lxd.InstanceServer
		arg3 string
		arg4 api.StorageVolume
		arg5 *lxd.StoragePoolVolumeCopyArgs
	}
	copyStoragePoolVolumeReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	copyStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CreateCertificateStub        func(api.CertificatesPost) error
	createCertificateMutex       sync.RWMutex
	createCertificateArgsForCall []struct {
		arg1 api.CertificatesPost
	}
	createCertificateReturns struct {
		result1 error
	}
	createCertificateReturnsOnCall map[int]struct {
		result1 error
	}
	CreateCertificateTokenStub        func(api.CertificatesPost) (lxd.Operation, error)
	createCertificateTokenMutex       sync.RWMutex
	createCertificateTokenArgsForCall []struct {
		arg1 api.CertificatesPost
	}
	createCertificateTokenReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createCertificateTokenReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateClusterGroupStub        func(api.ClusterGroupsPost) error
	createClusterGroupMutex       sync.RWMutex
	createClusterGroupArgsForCall []struct {
		arg1 api.ClusterGroupsPost
	}
	createClusterGroupReturns struct {
		result1 error
	}
	createClusterGroupReturnsOnCall map[int]struct {
		result1 error
	}
	CreateClusterMemberStub        func(api.ClusterMembersPost) (lxd.Operation, error)
	createClusterMemberMutex       sync.RWMutex
	createClusterMemberArgsForCall []struct {
		arg1 api.ClusterMembersPost
	}
	createClusterMemberReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createClusterMemberReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateContainerStub        func(api.ContainersPost) (lxd.Operation, error)
	createContainerMutex       sync.RWMutex
	createContainerArgsForCall []struct {
		arg1 api.ContainersPost
	}
	createContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateContainerBackupStub        func(string, api.ContainerBackupsPost) (lxd.Operation, error)
	createContainerBackupMutex       sync.RWMutex
	createContainerBackupArgsForCall []struct {
		arg1 string
		arg2 api.ContainerBackupsPost
	}
	createContainerBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createContainerBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateContainerFileStub        func(string, string, lxd.ContainerFileArgs) error
	createContainerFileMutex       sync.RWMutex
	createContainerFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 lxd.ContainerFileArgs
	}
	createContainerFileReturns struct {
		result1 error
	}
	createContainerFileReturnsOnCall map[int]struct {
		result1 error
	}
	CreateContainerFromBackupStub        func(lxd.ContainerBackupArgs) (lxd.Operation, error)
	createContainerFromBackupMutex       sync.RWMutex
	createContainerFromBackupArgsForCall []struct {
		arg1 lxd.ContainerBackupArgs
	}
	createContainerFromBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createContainerFromBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateContainerFromImageStub        func(lxd.ImageServer, api.Image, api.ContainersPost) (lxd.RemoteOperation, error)
	createContainerFromImageMutex       sync.RWMutex
	createContainerFromImageArgsForCall []struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 api.ContainersPost
	}
	createContainerFromImageReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	createContainerFromImageReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CreateContainerSnapshotStub        func(string, api.ContainerSnapshotsPost) (lxd.Operation, error)
	createContainerSnapshotMutex       sync.RWMutex
	createContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 api.ContainerSnapshotsPost
	}
	createContainerSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateContainerTemplateFileStub        func(string, string, io.ReadSeeker) error
	createContainerTemplateFileMutex       sync.RWMutex
	createContainerTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}
	createContainerTemplateFileReturns struct {
		result1 error
	}
	createContainerTemplateFileReturnsOnCall map[int]struct {
		result1 error
	}
	CreateImageStub        func(api.ImagesPost, *lxd.ImageCreateArgs) (lxd.Operation, error)
	createImageMutex       sync.RWMutex
	createImageArgsForCall []struct {
		arg1 api.ImagesPost
		arg2 *lxd.ImageCreateArgs
	}
	createImageReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createImageReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateImageAliasStub        func(api.ImageAliasesPost) error
	createImageAliasMutex       sync.RWMutex
	createImageAliasArgsForCall []struct {
		arg1 api.ImageAliasesPost
	}
	createImageAliasReturns struct {
		result1 error
	}
	createImageAliasReturnsOnCall map[int]struct {
		result1 error
	}
	CreateImageSecretStub        func(string) (lxd.Operation, error)
	createImageSecretMutex       sync.RWMutex
	createImageSecretArgsForCall []struct {
		arg1 string
	}
	createImageSecretReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createImageSecretReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateInstanceStub        func(api.InstancesPost) (lxd.Operation, error)
	createInstanceMutex       sync.RWMutex
	createInstanceArgsForCall []struct {
		arg1 api.InstancesPost
	}
	createInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateInstanceBackupStub        func(string, api.InstanceBackupsPost) (lxd.Operation, error)
	createInstanceBackupMutex       sync.RWMutex
	createInstanceBackupArgsForCall []struct {
		arg1 string
		arg2 api.InstanceBackupsPost
	}
	createInstanceBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createInstanceBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateInstanceFileStub        func(string, string, lxd.InstanceFileArgs) error
	createInstanceFileMutex       sync.RWMutex
	createInstanceFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 lxd.InstanceFileArgs
	}
	createInstanceFileReturns struct {
		result1 error
	}
	createInstanceFileReturnsOnCall map[int]struct {
		result1 error
	}
	CreateInstanceFromBackupStub        func(lxd.InstanceBackupArgs) (lxd.Operation, error)
	createInstanceFromBackupMutex       sync.RWMutex
	createInstanceFromBackupArgsForCall []struct {
		arg1 lxd.InstanceBackupArgs
	}
	createInstanceFromBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createInstanceFromBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateInstanceFromImageStub        func(lxd.ImageServer, api.Image, api.InstancesPost) (lxd.RemoteOperation, error)
	createInstanceFromImageMutex       sync.RWMutex
	createInstanceFromImageArgsForCall []struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 api.InstancesPost
	}
	createInstanceFromImageReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	createInstanceFromImageReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	CreateInstanceSnapshotStub        func(string, api.InstanceSnapshotsPost) (lxd.Operation, error)
	createInstanceSnapshotMutex       sync.RWMutex
	createInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 api.InstanceSnapshotsPost
	}
	createInstanceSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateInstanceTemplateFileStub        func(string, string, io.ReadSeeker) error
	createInstanceTemplateFileMutex       sync.RWMutex
	createInstanceTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}
	createInstanceTemplateFileReturns struct {
		result1 error
	}
	createInstanceTemplateFileReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkStub        func(api.NetworksPost) error
	createNetworkMutex       sync.RWMutex
	createNetworkArgsForCall []struct {
		arg1 api.NetworksPost
	}
	createNetworkReturns struct {
		result1 error
	}
	createNetworkReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkACLStub        func(api.NetworkACLsPost) error
	createNetworkACLMutex       sync.RWMutex
	createNetworkACLArgsForCall []struct {
		arg1 api.NetworkACLsPost
	}
	createNetworkACLReturns struct {
		result1 error
	}
	createNetworkACLReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkForwardStub        func(string, api.NetworkForwardsPost) error
	createNetworkForwardMutex       sync.RWMutex
	createNetworkForwardArgsForCall []struct {
		arg1 string
		arg2 api.NetworkForwardsPost
	}
	createNetworkForwardReturns struct {
		result1 error
	}
	createNetworkForwardReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkLoadBalancerStub        func(string, api.NetworkLoadBalancersPost) error
	createNetworkLoadBalancerMutex       sync.RWMutex
	createNetworkLoadBalancerArgsForCall []struct {
		arg1 string
		arg2 api.NetworkLoadBalancersPost
	}
	createNetworkLoadBalancerReturns struct {
		result1 error
	}
	createNetworkLoadBalancerReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkPeerStub        func(string, api.NetworkPeersPost) error
	createNetworkPeerMutex       sync.RWMutex
	createNetworkPeerArgsForCall []struct {
		arg1 string
		arg2 api.NetworkPeersPost
	}
	createNetworkPeerReturns struct {
		result1 error
	}
	createNetworkPeerReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkZoneStub        func(api.NetworkZonesPost) error
	createNetworkZoneMutex       sync.RWMutex
	createNetworkZoneArgsForCall []struct {
		arg1 api.NetworkZonesPost
	}
	createNetworkZoneReturns struct {
		result1 error
	}
	createNetworkZoneReturnsOnCall map[int]struct {
		result1 error
	}
	CreateNetworkZoneRecordStub        func(string, api.NetworkZoneRecordsPost) error
	createNetworkZoneRecordMutex       sync.RWMutex
	createNetworkZoneRecordArgsForCall []struct {
		arg1 string
		arg2 api.NetworkZoneRecordsPost
	}
	createNetworkZoneRecordReturns struct {
		result1 error
	}
	createNetworkZoneRecordReturnsOnCall map[int]struct {
		result1 error
	}
	CreateProfileStub        func(api.ProfilesPost) error
	createProfileMutex       sync.RWMutex
	createProfileArgsForCall []struct {
		arg1 api.ProfilesPost
	}
	createProfileReturns struct {
		result1 error
	}
	createProfileReturnsOnCall map[int]struct {
		result1 error
	}
	CreateProjectStub        func(api.ProjectsPost) error
	createProjectMutex       sync.RWMutex
	createProjectArgsForCall []struct {
		arg1 api.ProjectsPost
	}
	createProjectReturns struct {
		result1 error
	}
	createProjectReturnsOnCall map[int]struct {
		result1 error
	}
	CreateStoragePoolStub        func(api.StoragePoolsPost) error
	createStoragePoolMutex       sync.RWMutex
	createStoragePoolArgsForCall []struct {
		arg1 api.StoragePoolsPost
	}
	createStoragePoolReturns struct {
		result1 error
	}
	createStoragePoolReturnsOnCall map[int]struct {
		result1 error
	}
	CreateStoragePoolVolumeStub        func(string, api.StorageVolumesPost) error
	createStoragePoolVolumeMutex       sync.RWMutex
	createStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 api.StorageVolumesPost
	}
	createStoragePoolVolumeReturns struct {
		result1 error
	}
	createStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	CreateStoragePoolVolumeBackupStub        func(string, string, api.StoragePoolVolumeBackupsPost) (lxd.Operation, error)
	createStoragePoolVolumeBackupMutex       sync.RWMutex
	createStoragePoolVolumeBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.StoragePoolVolumeBackupsPost
	}
	createStoragePoolVolumeBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createStoragePoolVolumeBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateStoragePoolVolumeFromBackupStub        func(string, lxd.StoragePoolVolumeBackupArgs) (lxd.Operation, error)
	createStoragePoolVolumeFromBackupMutex       sync.RWMutex
	createStoragePoolVolumeFromBackupArgsForCall []struct {
		arg1 string
		arg2 lxd.StoragePoolVolumeBackupArgs
	}
	createStoragePoolVolumeFromBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createStoragePoolVolumeFromBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	CreateStoragePoolVolumeSnapshotStub        func(string, string, string, api.StorageVolumeSnapshotsPost) (lxd.Operation, error)
	createStoragePoolVolumeSnapshotMutex       sync.RWMutex
	createStoragePoolVolumeSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumeSnapshotsPost
	}
	createStoragePoolVolumeSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	createStoragePoolVolumeSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteCertificateStub        func(string) error
	deleteCertificateMutex       sync.RWMutex
	deleteCertificateArgsForCall []struct {
		arg1 string
	}
	deleteCertificateReturns struct {
		result1 error
	}
	deleteCertificateReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteClusterGroupStub        func(string) error
	deleteClusterGroupMutex       sync.RWMutex
	deleteClusterGroupArgsForCall []struct {
		arg1 string
	}
	deleteClusterGroupReturns struct {
		result1 error
	}
	deleteClusterGroupReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteClusterMemberStub        func(string, bool) error
	deleteClusterMemberMutex       sync.RWMutex
	deleteClusterMemberArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	deleteClusterMemberReturns struct {
		result1 error
	}
	deleteClusterMemberReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteContainerStub        func(string) (lxd.Operation, error)
	deleteContainerMutex       sync.RWMutex
	deleteContainerArgsForCall []struct {
		arg1 string
	}
	deleteContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteContainerBackupStub        func(string, string) (lxd.Operation, error)
	deleteContainerBackupMutex       sync.RWMutex
	deleteContainerBackupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteContainerBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteContainerBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteContainerConsoleLogStub        func(string, *lxd.ContainerConsoleLogArgs) error
	deleteContainerConsoleLogMutex       sync.RWMutex
	deleteContainerConsoleLogArgsForCall []struct {
		arg1 string
		arg2 *lxd.ContainerConsoleLogArgs
	}
	deleteContainerConsoleLogReturns struct {
		result1 error
	}
	deleteContainerConsoleLogReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteContainerFileStub        func(string, string) error
	deleteContainerFileMutex       sync.RWMutex
	deleteContainerFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteContainerFileReturns struct {
		result1 error
	}
	deleteContainerFileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteContainerLogfileStub        func(string, string) error
	deleteContainerLogfileMutex       sync.RWMutex
	deleteContainerLogfileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteContainerLogfileReturns struct {
		result1 error
	}
	deleteContainerLogfileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteContainerSnapshotStub        func(string, string) (lxd.Operation, error)
	deleteContainerSnapshotMutex       sync.RWMutex
	deleteContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteContainerSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteContainerTemplateFileStub        func(string, string) error
	deleteContainerTemplateFileMutex       sync.RWMutex
	deleteContainerTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteContainerTemplateFileReturns struct {
		result1 error
	}
	deleteContainerTemplateFileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteImageStub        func(string) (lxd.Operation, error)
	deleteImageMutex       sync.RWMutex
	deleteImageArgsForCall []struct {
		arg1 string
	}
	deleteImageReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteImageReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteImageAliasStub        func(string) error
	deleteImageAliasMutex       sync.RWMutex
	deleteImageAliasArgsForCall []struct {
		arg1 string
	}
	deleteImageAliasReturns struct {
		result1 error
	}
	deleteImageAliasReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteInstanceStub        func(string) (lxd.Operation, error)
	deleteInstanceMutex       sync.RWMutex
	deleteInstanceArgsForCall []struct {
		arg1 string
	}
	deleteInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteInstanceBackupStub        func(string, string) (lxd.Operation, error)
	deleteInstanceBackupMutex       sync.RWMutex
	deleteInstanceBackupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteInstanceBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteInstanceBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteInstanceConsoleLogStub        func(string, *lxd.InstanceConsoleLogArgs) error
	deleteInstanceConsoleLogMutex       sync.RWMutex
	deleteInstanceConsoleLogArgsForCall []struct {
		arg1 string
		arg2 *lxd.InstanceConsoleLogArgs
	}
	deleteInstanceConsoleLogReturns struct {
		result1 error
	}
	deleteInstanceConsoleLogReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteInstanceFileStub        func(string, string) error
	deleteInstanceFileMutex       sync.RWMutex
	deleteInstanceFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteInstanceFileReturns struct {
		result1 error
	}
	deleteInstanceFileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteInstanceLogfileStub        func(string, string) error
	deleteInstanceLogfileMutex       sync.RWMutex
	deleteInstanceLogfileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteInstanceLogfileReturns struct {
		result1 error
	}
	deleteInstanceLogfileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteInstanceSnapshotStub        func(string, string) (lxd.Operation, error)
	deleteInstanceSnapshotMutex       sync.RWMutex
	deleteInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteInstanceSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteInstanceTemplateFileStub        func(string, string) error
	deleteInstanceTemplateFileMutex       sync.RWMutex
	deleteInstanceTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteInstanceTemplateFileReturns struct {
		result1 error
	}
	deleteInstanceTemplateFileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkStub        func(string) error
	deleteNetworkMutex       sync.RWMutex
	deleteNetworkArgsForCall []struct {
		arg1 string
	}
	deleteNetworkReturns struct {
		result1 error
	}
	deleteNetworkReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkACLStub        func(string) error
	deleteNetworkACLMutex       sync.RWMutex
	deleteNetworkACLArgsForCall []struct {
		arg1 string
	}
	deleteNetworkACLReturns struct {
		result1 error
	}
	deleteNetworkACLReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkForwardStub        func(string, string) error
	deleteNetworkForwardMutex       sync.RWMutex
	deleteNetworkForwardArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteNetworkForwardReturns struct {
		result1 error
	}
	deleteNetworkForwardReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkLoadBalancerStub        func(string, string) error
	deleteNetworkLoadBalancerMutex       sync.RWMutex
	deleteNetworkLoadBalancerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteNetworkLoadBalancerReturns struct {
		result1 error
	}
	deleteNetworkLoadBalancerReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkPeerStub        func(string, string) error
	deleteNetworkPeerMutex       sync.RWMutex
	deleteNetworkPeerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteNetworkPeerReturns struct {
		result1 error
	}
	deleteNetworkPeerReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkZoneStub        func(string) error
	deleteNetworkZoneMutex       sync.RWMutex
	deleteNetworkZoneArgsForCall []struct {
		arg1 string
	}
	deleteNetworkZoneReturns struct {
		result1 error
	}
	deleteNetworkZoneReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteNetworkZoneRecordStub        func(string, string) error
	deleteNetworkZoneRecordMutex       sync.RWMutex
	deleteNetworkZoneRecordArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteNetworkZoneRecordReturns struct {
		result1 error
	}
	deleteNetworkZoneRecordReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteOperationStub        func(string) error
	deleteOperationMutex       sync.RWMutex
	deleteOperationArgsForCall []struct {
		arg1 string
	}
	deleteOperationReturns struct {
		result1 error
	}
	deleteOperationReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteProfileStub        func(string) error
	deleteProfileMutex       sync.RWMutex
	deleteProfileArgsForCall []struct {
		arg1 string
	}
	deleteProfileReturns struct {
		result1 error
	}
	deleteProfileReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteProjectStub        func(string) error
	deleteProjectMutex       sync.RWMutex
	deleteProjectArgsForCall []struct {
		arg1 string
	}
	deleteProjectReturns struct {
		result1 error
	}
	deleteProjectReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStoragePoolStub        func(string) error
	deleteStoragePoolMutex       sync.RWMutex
	deleteStoragePoolArgsForCall []struct {
		arg1 string
	}
	deleteStoragePoolReturns struct {
		result1 error
	}
	deleteStoragePoolReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStoragePoolVolumeStub        func(string, string, string) error
	deleteStoragePoolVolumeMutex       sync.RWMutex
	deleteStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	deleteStoragePoolVolumeReturns struct {
		result1 error
	}
	deleteStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStoragePoolVolumeBackupStub        func(string, string, string) (lxd.Operation, error)
	deleteStoragePoolVolumeBackupMutex       sync.RWMutex
	deleteStoragePoolVolumeBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	deleteStoragePoolVolumeBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteStoragePoolVolumeBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteStoragePoolVolumeSnapshotStub        func(string, string, string, string) (lxd.Operation, error)
	deleteStoragePoolVolumeSnapshotMutex       sync.RWMutex
	deleteStoragePoolVolumeSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}
	deleteStoragePoolVolumeSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	deleteStoragePoolVolumeSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	DeleteWarningStub        func(string) error
	deleteWarningMutex       sync.RWMutex
	deleteWarningArgsForCall []struct {
		arg1 string
	}
	deleteWarningReturns struct {
		result1 error
	}
	deleteWarningReturnsOnCall map[int]struct {
		result1 error
	}
	DisconnectStub        func()
	disconnectMutex       sync.RWMutex
	disconnectArgsForCall []struct {
	}
	DoHTTPStub        func(*http.Request) (*http.Response, error)
	doHTTPMutex       sync.RWMutex
	doHTTPArgsForCall []struct {
		arg1 *http.Request
	}
	doHTTPReturns struct {
		result1 *http.Response
		result2 error
	}
	doHTTPReturnsOnCall map[int]struct {
		result1 *http.Response
		result2 error
	}
	ExecContainerStub        func(string, api.ContainerExecPost, *lxd.ContainerExecArgs) (lxd.Operation, error)
	execContainerMutex       sync.RWMutex
	execContainerArgsForCall []struct {
		arg1 string
		arg2 api.ContainerExecPost
		arg3 *lxd.ContainerExecArgs
	}
	execContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	execContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	ExecInstanceStub        func(string, api.InstanceExecPost, *lxd.InstanceExecArgs) (lxd.Operation, error)
	execInstanceMutex       sync.RWMutex
	execInstanceArgsForCall []struct {
		arg1 string
		arg2 api.InstanceExecPost
		arg3 *lxd.InstanceExecArgs
	}
	execInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	execInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	ExportImageStub        func(string, api.ImageExportPost) (lxd.Operation, error)
	exportImageMutex       sync.RWMutex
	exportImageArgsForCall []struct {
		arg1 string
		arg2 api.ImageExportPost
	}
	exportImageReturns struct {
		result1 lxd.Operation
		result2 error
	}
	exportImageReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	GetCertificateStub        func(string) (*api.Certificate, string, error)
	getCertificateMutex       sync.RWMutex
	getCertificateArgsForCall []struct {
		arg1 string
	}
	getCertificateReturns struct {
		result1 *api.Certificate
		result2 string
		result3 error
	}
	getCertificateReturnsOnCall map[int]struct {
		result1 *api.Certificate
		result2 string
		result3 error
	}
	GetCertificateFingerprintsStub        func() ([]string, error)
	getCertificateFingerprintsMutex       sync.RWMutex
	getCertificateFingerprintsArgsForCall []struct {
	}
	getCertificateFingerprintsReturns struct {
		result1 []string
		result2 error
	}
	getCertificateFingerprintsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetCertificatesStub        func() ([]api.Certificate, error)
	getCertificatesMutex       sync.RWMutex
	getCertificatesArgsForCall []struct {
	}
	getCertificatesReturns struct {
		result1 []api.Certificate
		result2 error
	}
	getCertificatesReturnsOnCall map[int]struct {
		result1 []api.Certificate
		result2 error
	}
	GetClusterStub        func() (*api.Cluster, string, error)
	getClusterMutex       sync.RWMutex
	getClusterArgsForCall []struct {
	}
	getClusterReturns struct {
		result1 *api.Cluster
		result2 string
		result3 error
	}
	getClusterReturnsOnCall map[int]struct {
		result1 *api.Cluster
		result2 string
		result3 error
	}
	GetClusterGroupStub        func(string) (*api.ClusterGroup, string, error)
	getClusterGroupMutex       sync.RWMutex
	getClusterGroupArgsForCall []struct {
		arg1 string
	}
	getClusterGroupReturns struct {
		result1 *api.ClusterGroup
		result2 string
		result3 error
	}
	getClusterGroupReturnsOnCall map[int]struct {
		result1 *api.ClusterGroup
		result2 string
		result3 error
	}
	GetClusterGroupNamesStub        func() ([]string, error)
	getClusterGroupNamesMutex       sync.RWMutex
	getClusterGroupNamesArgsForCall []struct {
	}
	getClusterGroupNamesReturns struct {
		result1 []string
		result2 error
	}
	getClusterGroupNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetClusterGroupsStub        func() ([]api.ClusterGroup, error)
	getClusterGroupsMutex       sync.RWMutex
	getClusterGroupsArgsForCall []struct {
	}
	getClusterGroupsReturns struct {
		result1 []api.ClusterGroup
		result2 error
	}
	getClusterGroupsReturnsOnCall map[int]struct {
		result1 []api.ClusterGroup
		result2 error
	}
	GetClusterMemberStub        func(string) (*api.ClusterMember, string, error)
	getClusterMemberMutex       sync.RWMutex
	getClusterMemberArgsForCall []struct {
		arg1 string
	}
	getClusterMemberReturns struct {
		result1 *api.ClusterMember
		result2 string
		result3 error
	}
	getClusterMemberReturnsOnCall map[int]struct {
		result1 *api.ClusterMember
		result2 string
		result3 error
	}
	GetClusterMemberNamesStub        func() ([]string, error)
	getClusterMemberNamesMutex       sync.RWMutex
	getClusterMemberNamesArgsForCall []struct {
	}
	getClusterMemberNamesReturns struct {
		result1 []string
		result2 error
	}
	getClusterMemberNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetClusterMembersStub        func() ([]api.ClusterMember, error)
	getClusterMembersMutex       sync.RWMutex
	getClusterMembersArgsForCall []struct {
	}
	getClusterMembersReturns struct {
		result1 []api.ClusterMember
		result2 error
	}
	getClusterMembersReturnsOnCall map[int]struct {
		result1 []api.ClusterMember
		result2 error
	}
	GetConnectionInfoStub        func() (*lxd.ConnectionInfo, error)
	getConnectionInfoMutex       sync.RWMutex
	getConnectionInfoArgsForCall []struct {
	}
	getConnectionInfoReturns struct {
		result1 *lxd.ConnectionInfo
		result2 error
	}
	getConnectionInfoReturnsOnCall map[int]struct {
		result1 *lxd.ConnectionInfo
		result2 error
	}
	GetContainerStub        func(string) (*api.Container, string, error)
	getContainerMutex       sync.RWMutex
	getContainerArgsForCall []struct {
		arg1 string
	}
	getContainerReturns struct {
		result1 *api.Container
		result2 string
		result3 error
	}
	getContainerReturnsOnCall map[int]struct {
		result1 *api.Container
		result2 string
		result3 error
	}
	GetContainerBackupStub        func(string, string) (*api.ContainerBackup, string, error)
	getContainerBackupMutex       sync.RWMutex
	getContainerBackupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getContainerBackupReturns struct {
		result1 *api.ContainerBackup
		result2 string
		result3 error
	}
	getContainerBackupReturnsOnCall map[int]struct {
		result1 *api.ContainerBackup
		result2 string
		result3 error
	}
	GetContainerBackupFileStub        func(string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)
	getContainerBackupFileMutex       sync.RWMutex
	getContainerBackupFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 *lxd.BackupFileRequest
	}
	getContainerBackupFileReturns struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	getContainerBackupFileReturnsOnCall map[int]struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	GetContainerBackupNamesStub        func(string) ([]string, error)
	getContainerBackupNamesMutex       sync.RWMutex
	getContainerBackupNamesArgsForCall []struct {
		arg1 string
	}
	getContainerBackupNamesReturns struct {
		result1 []string
		result2 error
	}
	getContainerBackupNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetContainerBackupsStub        func(string) ([]api.ContainerBackup, error)
	getContainerBackupsMutex       sync.RWMutex
	getContainerBackupsArgsForCall []struct {
		arg1 string
	}
	getContainerBackupsReturns struct {
		result1 []api.ContainerBackup
		result2 error
	}
	getContainerBackupsReturnsOnCall map[int]struct {
		result1 []api.ContainerBackup
		result2 error
	}
	GetContainerConsoleLogStub        func(string, *lxd.ContainerConsoleLogArgs) (io.ReadCloser, error)
	getContainerConsoleLogMutex       sync.RWMutex
	getContainerConsoleLogArgsForCall []struct {
		arg1 string
		arg2 *lxd.ContainerConsoleLogArgs
	}
	getContainerConsoleLogReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getContainerConsoleLogReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetContainerFileStub        func(string, string) (io.ReadCloser, *lxd.ContainerFileResponse, error)
	getContainerFileMutex       sync.RWMutex
	getContainerFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getContainerFileReturns struct {
		result1 io.ReadCloser
		result2 *lxd.ContainerFileResponse
		result3 error
	}
	getContainerFileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 *lxd.ContainerFileResponse
		result3 error
	}
	GetContainerLogfileStub        func(string, string) (io.ReadCloser, error)
	getContainerLogfileMutex       sync.RWMutex
	getContainerLogfileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getContainerLogfileReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getContainerLogfileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetContainerLogfilesStub        func(string) ([]string, error)
	getContainerLogfilesMutex       sync.RWMutex
	getContainerLogfilesArgsForCall []struct {
		arg1 string
	}
	getContainerLogfilesReturns struct {
		result1 []string
		result2 error
	}
	getContainerLogfilesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetContainerMetadataStub        func(string) (*api.ImageMetadata, string, error)
	getContainerMetadataMutex       sync.RWMutex
	getContainerMetadataArgsForCall []struct {
		arg1 string
	}
	getContainerMetadataReturns struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}
	getContainerMetadataReturnsOnCall map[int]struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}
	GetContainerNamesStub        func() ([]string, error)
	getContainerNamesMutex       sync.RWMutex
	getContainerNamesArgsForCall []struct {
	}
	getContainerNamesReturns struct {
		result1 []string
		result2 error
	}
	getContainerNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetContainerSnapshotStub        func(string, string) (*api.ContainerSnapshot, string, error)
	getContainerSnapshotMutex       sync.RWMutex
	getContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getContainerSnapshotReturns struct {
		result1 *api.ContainerSnapshot
		result2 string
		result3 error
	}
	getContainerSnapshotReturnsOnCall map[int]struct {
		result1 *api.ContainerSnapshot
		result2 string
		result3 error
	}
	GetContainerSnapshotNamesStub        func(string) ([]string, error)
	getContainerSnapshotNamesMutex       sync.RWMutex
	getContainerSnapshotNamesArgsForCall []struct {
		arg1 string
	}
	getContainerSnapshotNamesReturns struct {
		result1 []string
		result2 error
	}
	getContainerSnapshotNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetContainerSnapshotsStub        func(string) ([]api.ContainerSnapshot, error)
	getContainerSnapshotsMutex       sync.RWMutex
	getContainerSnapshotsArgsForCall []struct {
		arg1 string
	}
	getContainerSnapshotsReturns struct {
		result1 []api.ContainerSnapshot
		result2 error
	}
	getContainerSnapshotsReturnsOnCall map[int]struct {
		result1 []api.ContainerSnapshot
		result2 error
	}
	GetContainerStateStub        func(string) (*api.ContainerState, string, error)
	getContainerStateMutex       sync.RWMutex
	getContainerStateArgsForCall []struct {
		arg1 string
	}
	getContainerStateReturns struct {
		result1 *api.ContainerState
		result2 string
		result3 error
	}
	getContainerStateReturnsOnCall map[int]struct {
		result1 *api.ContainerState
		result2 string
		result3 error
	}
	GetContainerTemplateFileStub        func(string, string) (io.ReadCloser, error)
	getContainerTemplateFileMutex       sync.RWMutex
	getContainerTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getContainerTemplateFileReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getContainerTemplateFileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetContainerTemplateFilesStub        func(string) ([]string, error)
	getContainerTemplateFilesMutex       sync.RWMutex
	getContainerTemplateFilesArgsForCall []struct {
		arg1 string
	}
	getContainerTemplateFilesReturns struct {
		result1 []string
		result2 error
	}
	getContainerTemplateFilesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetContainersStub        func() ([]api.Container, error)
	getContainersMutex       sync.RWMutex
	getContainersArgsForCall []struct {
	}
	getContainersReturns struct {
		result1 []api.Container
		result2 error
	}
	getContainersReturnsOnCall map[int]struct {
		result1 []api.Container
		result2 error
	}
	GetContainersFullStub        func() ([]api.ContainerFull, error)
	getContainersFullMutex       sync.RWMutex
	getContainersFullArgsForCall []struct {
	}
	getContainersFullReturns struct {
		result1 []api.ContainerFull
		result2 error
	}
	getContainersFullReturnsOnCall map[int]struct {
		result1 []api.ContainerFull
		result2 error
	}
	GetEventsStub        func() (*lxd.EventListener, error)
	getEventsMutex       sync.RWMutex
	getEventsArgsForCall []struct {
	}
	getEventsReturns struct {
		result1 *lxd.EventListener
		result2 error
	}
	getEventsReturnsOnCall map[int]struct {
		result1 *lxd.EventListener
		result2 error
	}
	GetEventsAllProjectsStub        func() (*lxd.EventListener, error)
	getEventsAllProjectsMutex       sync.RWMutex
	getEventsAllProjectsArgsForCall []struct {
	}
	getEventsAllProjectsReturns struct {
		result1 *lxd.EventListener
		result2 error
	}
	getEventsAllProjectsReturnsOnCall map[int]struct {
		result1 *lxd.EventListener
		result2 error
	}
	GetHTTPClientStub        func() (*http.Client, error)
	getHTTPClientMutex       sync.RWMutex
	getHTTPClientArgsForCall []struct {
	}
	getHTTPClientReturns struct {
		result1 *http.Client
		result2 error
	}
	getHTTPClientReturnsOnCall map[int]struct {
		result1 *http.Client
		result2 error
	}
	GetImageStub        func(string) (*api.Image, string, error)
	getImageMutex       sync.RWMutex
	getImageArgsForCall []struct {
		arg1 string
	}
	getImageReturns struct {
		result1 *api.Image
		result2 string
		result3 error
	}
	getImageReturnsOnCall map[int]struct {
		result1 *api.Image
		result2 string
		result3 error
	}
	GetImageAliasStub        func(string) (*api.ImageAliasesEntry, string, error)
	getImageAliasMutex       sync.RWMutex
	getImageAliasArgsForCall []struct {
		arg1 string
	}
	getImageAliasReturns struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}
	getImageAliasReturnsOnCall map[int]struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}
	GetImageAliasArchitecturesStub        func(string, string) (map[string]*api.ImageAliasesEntry, error)
	getImageAliasArchitecturesMutex       sync.RWMutex
	getImageAliasArchitecturesArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getImageAliasArchitecturesReturns struct {
		result1 map[string]*api.ImageAliasesEntry
		result2 error
	}
	getImageAliasArchitecturesReturnsOnCall map[int]struct {
		result1 map[string]*api.ImageAliasesEntry
		result2 error
	}
	GetImageAliasNamesStub        func() ([]string, error)
	getImageAliasNamesMutex       sync.RWMutex
	getImageAliasNamesArgsForCall []struct {
	}
	getImageAliasNamesReturns struct {
		result1 []string
		result2 error
	}
	getImageAliasNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetImageAliasTypeStub        func(string, string) (*api.ImageAliasesEntry, string, error)
	getImageAliasTypeMutex       sync.RWMutex
	getImageAliasTypeArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getImageAliasTypeReturns struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}
	getImageAliasTypeReturnsOnCall map[int]struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}
	GetImageAliasesStub        func() ([]api.ImageAliasesEntry, error)
	getImageAliasesMutex       sync.RWMutex
	getImageAliasesArgsForCall []struct {
	}
	getImageAliasesReturns struct {
		result1 []api.ImageAliasesEntry
		result2 error
	}
	getImageAliasesReturnsOnCall map[int]struct {
		result1 []api.ImageAliasesEntry
		result2 error
	}
	GetImageFileStub        func(string, lxd.ImageFileRequest) (*lxd.ImageFileResponse, error)
	getImageFileMutex       sync.RWMutex
	getImageFileArgsForCall []struct {
		arg1 string
		arg2 lxd.ImageFileRequest
	}
	getImageFileReturns struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}
	getImageFileReturnsOnCall map[int]struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}
	GetImageFingerprintsStub        func() ([]string, error)
	getImageFingerprintsMutex       sync.RWMutex
	getImageFingerprintsArgsForCall []struct {
	}
	getImageFingerprintsReturns struct {
		result1 []string
		result2 error
	}
	getImageFingerprintsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetImageSecretStub        func(string) (string, error)
	getImageSecretMutex       sync.RWMutex
	getImageSecretArgsForCall []struct {
		arg1 string
	}
	getImageSecretReturns struct {
		result1 string
		result2 error
	}
	getImageSecretReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	GetImagesStub        func() ([]api.Image, error)
	getImagesMutex       sync.RWMutex
	getImagesArgsForCall []struct {
	}
	getImagesReturns struct {
		result1 []api.Image
		result2 error
	}
	getImagesReturnsOnCall map[int]struct {
		result1 []api.Image
		result2 error
	}
	GetImagesWithFilterStub        func([]string) ([]api.Image, error)
	getImagesWithFilterMutex       sync.RWMutex
	getImagesWithFilterArgsForCall []struct {
		arg1 []string
	}
	getImagesWithFilterReturns struct {
		result1 []api.Image
		result2 error
	}
	getImagesWithFilterReturnsOnCall map[int]struct {
		result1 []api.Image
		result2 error
	}
	GetInstanceStub        func(string) (*api.Instance, string, error)
	getInstanceMutex       sync.RWMutex
	getInstanceArgsForCall []struct {
		arg1 string
	}
	getInstanceReturns struct {
		result1 *api.Instance
		result2 string
		result3 error
	}
	getInstanceReturnsOnCall map[int]struct {
		result1 *api.Instance
		result2 string
		result3 error
	}
	GetInstanceBackupStub        func(string, string) (*api.InstanceBackup, string, error)
	getInstanceBackupMutex       sync.RWMutex
	getInstanceBackupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getInstanceBackupReturns struct {
		result1 *api.InstanceBackup
		result2 string
		result3 error
	}
	getInstanceBackupReturnsOnCall map[int]struct {
		result1 *api.InstanceBackup
		result2 string
		result3 error
	}
	GetInstanceBackupFileStub        func(string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)
	getInstanceBackupFileMutex       sync.RWMutex
	getInstanceBackupFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 *lxd.BackupFileRequest
	}
	getInstanceBackupFileReturns struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	getInstanceBackupFileReturnsOnCall map[int]struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	GetInstanceBackupNamesStub        func(string) ([]string, error)
	getInstanceBackupNamesMutex       sync.RWMutex
	getInstanceBackupNamesArgsForCall []struct {
		arg1 string
	}
	getInstanceBackupNamesReturns struct {
		result1 []string
		result2 error
	}
	getInstanceBackupNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetInstanceBackupsStub        func(string) ([]api.InstanceBackup, error)
	getInstanceBackupsMutex       sync.RWMutex
	getInstanceBackupsArgsForCall []struct {
		arg1 string
	}
	getInstanceBackupsReturns struct {
		result1 []api.InstanceBackup
		result2 error
	}
	getInstanceBackupsReturnsOnCall map[int]struct {
		result1 []api.InstanceBackup
		result2 error
	}
	GetInstanceConsoleLogStub        func(string, *lxd.InstanceConsoleLogArgs) (io.ReadCloser, error)
	getInstanceConsoleLogMutex       sync.RWMutex
	getInstanceConsoleLogArgsForCall []struct {
		arg1 string
		arg2 *lxd.InstanceConsoleLogArgs
	}
	getInstanceConsoleLogReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getInstanceConsoleLogReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetInstanceFileStub        func(string, string) (io.ReadCloser, *lxd.InstanceFileResponse, error)
	getInstanceFileMutex       sync.RWMutex
	getInstanceFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getInstanceFileReturns struct {
		result1 io.ReadCloser
		result2 *lxd.InstanceFileResponse
		result3 error
	}
	getInstanceFileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 *lxd.InstanceFileResponse
		result3 error
	}
	GetInstanceFileSFTPStub        func(string) (*sftp.Client, error)
	getInstanceFileSFTPMutex       sync.RWMutex
	getInstanceFileSFTPArgsForCall []struct {
		arg1 string
	}
	getInstanceFileSFTPReturns struct {
		result1 *sftp.Client
		result2 error
	}
	getInstanceFileSFTPReturnsOnCall map[int]struct {
		result1 *sftp.Client
		result2 error
	}
	GetInstanceFileSFTPConnStub        func(string) (net.Conn, error)
	getInstanceFileSFTPConnMutex       sync.RWMutex
	getInstanceFileSFTPConnArgsForCall []struct {
		arg1 string
	}
	getInstanceFileSFTPConnReturns struct {
		result1 net.Conn
		result2 error
	}
	getInstanceFileSFTPConnReturnsOnCall map[int]struct {
		result1 net.Conn
		result2 error
	}
	GetInstanceFullStub        func(string) (*api.InstanceFull, string, error)
	getInstanceFullMutex       sync.RWMutex
	getInstanceFullArgsForCall []struct {
		arg1 string
	}
	getInstanceFullReturns struct {
		result1 *api.InstanceFull
		result2 string
		result3 error
	}
	getInstanceFullReturnsOnCall map[int]struct {
		result1 *api.InstanceFull
		result2 string
		result3 error
	}
	GetInstanceLogfileStub        func(string, string) (io.ReadCloser, error)
	getInstanceLogfileMutex       sync.RWMutex
	getInstanceLogfileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getInstanceLogfileReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getInstanceLogfileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetInstanceLogfilesStub        func(string) ([]string, error)
	getInstanceLogfilesMutex       sync.RWMutex
	getInstanceLogfilesArgsForCall []struct {
		arg1 string
	}
	getInstanceLogfilesReturns struct {
		result1 []string
		result2 error
	}
	getInstanceLogfilesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetInstanceMetadataStub        func(string) (*api.ImageMetadata, string, error)
	getInstanceMetadataMutex       sync.RWMutex
	getInstanceMetadataArgsForCall []struct {
		arg1 string
	}
	getInstanceMetadataReturns struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}
	getInstanceMetadataReturnsOnCall map[int]struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}
	GetInstanceNamesStub        func(api.InstanceType) ([]string, error)
	getInstanceNamesMutex       sync.RWMutex
	getInstanceNamesArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstanceNamesReturns struct {
		result1 []string
		result2 error
	}
	getInstanceNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetInstanceNamesAllProjectsStub        func(api.InstanceType) (map[string][]string, error)
	getInstanceNamesAllProjectsMutex       sync.RWMutex
	getInstanceNamesAllProjectsArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstanceNamesAllProjectsReturns struct {
		result1 map[string][]string
		result2 error
	}
	getInstanceNamesAllProjectsReturnsOnCall map[int]struct {
		result1 map[string][]string
		result2 error
	}
	GetInstanceSnapshotStub        func(string, string) (*api.InstanceSnapshot, string, error)
	getInstanceSnapshotMutex       sync.RWMutex
	getInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getInstanceSnapshotReturns struct {
		result1 *api.InstanceSnapshot
		result2 string
		result3 error
	}
	getInstanceSnapshotReturnsOnCall map[int]struct {
		result1 *api.InstanceSnapshot
		result2 string
		result3 error
	}
	GetInstanceSnapshotNamesStub        func(string) ([]string, error)
	getInstanceSnapshotNamesMutex       sync.RWMutex
	getInstanceSnapshotNamesArgsForCall []struct {
		arg1 string
	}
	getInstanceSnapshotNamesReturns struct {
		result1 []string
		result2 error
	}
	getInstanceSnapshotNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetInstanceSnapshotsStub        func(string) ([]api.InstanceSnapshot, error)
	getInstanceSnapshotsMutex       sync.RWMutex
	getInstanceSnapshotsArgsForCall []struct {
		arg1 string
	}
	getInstanceSnapshotsReturns struct {
		result1 []api.InstanceSnapshot
		result2 error
	}
	getInstanceSnapshotsReturnsOnCall map[int]struct {
		result1 []api.InstanceSnapshot
		result2 error
	}
	GetInstanceStateStub        func(string) (*api.InstanceState, string, error)
	getInstanceStateMutex       sync.RWMutex
	getInstanceStateArgsForCall []struct {
		arg1 string
	}
	getInstanceStateReturns struct {
		result1 *api.InstanceState
		result2 string
		result3 error
	}
	getInstanceStateReturnsOnCall map[int]struct {
		result1 *api.InstanceState
		result2 string
		result3 error
	}
	GetInstanceTemplateFileStub        func(string, string) (io.ReadCloser, error)
	getInstanceTemplateFileMutex       sync.RWMutex
	getInstanceTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getInstanceTemplateFileReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getInstanceTemplateFileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetInstanceTemplateFilesStub        func(string) ([]string, error)
	getInstanceTemplateFilesMutex       sync.RWMutex
	getInstanceTemplateFilesArgsForCall []struct {
		arg1 string
	}
	getInstanceTemplateFilesReturns struct {
		result1 []string
		result2 error
	}
	getInstanceTemplateFilesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetInstancesStub        func(api.InstanceType) ([]api.Instance, error)
	getInstancesMutex       sync.RWMutex
	getInstancesArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstancesReturns struct {
		result1 []api.Instance
		result2 error
	}
	getInstancesReturnsOnCall map[int]struct {
		result1 []api.Instance
		result2 error
	}
	GetInstancesAllProjectsStub        func(api.InstanceType) ([]api.Instance, error)
	getInstancesAllProjectsMutex       sync.RWMutex
	getInstancesAllProjectsArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstancesAllProjectsReturns struct {
		result1 []api.Instance
		result2 error
	}
	getInstancesAllProjectsReturnsOnCall map[int]struct {
		result1 []api.Instance
		result2 error
	}
	GetInstancesAllProjectsWithFilterStub        func(api.InstanceType, []string) ([]api.Instance, error)
	getInstancesAllProjectsWithFilterMutex       sync.RWMutex
	getInstancesAllProjectsWithFilterArgsForCall []struct {
		arg1 api.InstanceType
		arg2 []string
	}
	getInstancesAllProjectsWithFilterReturns struct {
		result1 []api.Instance
		result2 error
	}
	getInstancesAllProjectsWithFilterReturnsOnCall map[int]struct {
		result1 []api.Instance
		result2 error
	}
	GetInstancesFullStub        func(api.InstanceType) ([]api.InstanceFull, error)
	getInstancesFullMutex       sync.RWMutex
	getInstancesFullArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstancesFullReturns struct {
		result1 []api.InstanceFull
		result2 error
	}
	getInstancesFullReturnsOnCall map[int]struct {
		result1 []api.InstanceFull
		result2 error
	}
	GetInstancesFullAllProjectsStub        func(api.InstanceType) ([]api.InstanceFull, error)
	getInstancesFullAllProjectsMutex       sync.RWMutex
	getInstancesFullAllProjectsArgsForCall []struct {
		arg1 api.InstanceType
	}
	getInstancesFullAllProjectsReturns struct {
		result1 []api.InstanceFull
		result2 error
	}
	getInstancesFullAllProjectsReturnsOnCall map[int]struct {
		result1 []api.InstanceFull
		result2 error
	}
	GetInstancesFullAllProjectsWithFilterStub        func(api.InstanceType, []string) ([]api.InstanceFull, error)
	getInstancesFullAllProjectsWithFilterMutex       sync.RWMutex
	getInstancesFullAllProjectsWithFilterArgsForCall []struct {
		arg1 api.InstanceType
		arg2 []string
	}
	getInstancesFullAllProjectsWithFilterReturns struct {
		result1 []api.InstanceFull
		result2 error
	}
	getInstancesFullAllProjectsWithFilterReturnsOnCall map[int]struct {
		result1 []api.InstanceFull
		result2 error
	}
	GetInstancesFullWithFilterStub        func(api.InstanceType, []string) ([]api.InstanceFull, error)
	getInstancesFullWithFilterMutex       sync.RWMutex
	getInstancesFullWithFilterArgsForCall []struct {
		arg1 api.InstanceType
		arg2 []string
	}
	getInstancesFullWithFilterReturns struct {
		result1 []api.InstanceFull
		result2 error
	}
	getInstancesFullWithFilterReturnsOnCall map[int]struct {
		result1 []api.InstanceFull
		result2 error
	}
	GetInstancesWithFilterStub        func(api.InstanceType, []string) ([]api.Instance, error)
	getInstancesWithFilterMutex       sync.RWMutex
	getInstancesWithFilterArgsForCall []struct {
		arg1 api.InstanceType
		arg2 []string
	}
	getInstancesWithFilterReturns struct {
		result1 []api.Instance
		result2 error
	}
	getInstancesWithFilterReturnsOnCall map[int]struct {
		result1 []api.Instance
		result2 error
	}
	GetMetricsStub        func() (string, error)
	getMetricsMutex       sync.RWMutex
	getMetricsArgsForCall []struct {
	}
	getMetricsReturns struct {
		result1 string
		result2 error
	}
	getMetricsReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	GetNetworkStub        func(string) (*api.Network, string, error)
	getNetworkMutex       sync.RWMutex
	getNetworkArgsForCall []struct {
		arg1 string
	}
	getNetworkReturns struct {
		result1 *api.Network
		result2 string
		result3 error
	}
	getNetworkReturnsOnCall map[int]struct {
		result1 *api.Network
		result2 string
		result3 error
	}
	GetNetworkACLStub        func(string) (*api.NetworkACL, string, error)
	getNetworkACLMutex       sync.RWMutex
	getNetworkACLArgsForCall []struct {
		arg1 string
	}
	getNetworkACLReturns struct {
		result1 *api.NetworkACL
		result2 string
		result3 error
	}
	getNetworkACLReturnsOnCall map[int]struct {
		result1 *api.NetworkACL
		result2 string
		result3 error
	}
	GetNetworkACLLogfileStub        func(string) (io.ReadCloser, error)
	getNetworkACLLogfileMutex       sync.RWMutex
	getNetworkACLLogfileArgsForCall []struct {
		arg1 string
	}
	getNetworkACLLogfileReturns struct {
		result1 io.ReadCloser
		result2 error
	}
	getNetworkACLLogfileReturnsOnCall map[int]struct {
		result1 io.ReadCloser
		result2 error
	}
	GetNetworkACLNamesStub        func() ([]string, error)
	getNetworkACLNamesMutex       sync.RWMutex
	getNetworkACLNamesArgsForCall []struct {
	}
	getNetworkACLNamesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkACLNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkACLsStub        func() ([]api.NetworkACL, error)
	getNetworkACLsMutex       sync.RWMutex
	getNetworkACLsArgsForCall []struct {
	}
	getNetworkACLsReturns struct {
		result1 []api.NetworkACL
		result2 error
	}
	getNetworkACLsReturnsOnCall map[int]struct {
		result1 []api.NetworkACL
		result2 error
	}
	GetNetworkForwardStub        func(string, string) (*api.NetworkForward, string, error)
	getNetworkForwardMutex       sync.RWMutex
	getNetworkForwardArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getNetworkForwardReturns struct {
		result1 *api.NetworkForward
		result2 string
		result3 error
	}
	getNetworkForwardReturnsOnCall map[int]struct {
		result1 *api.NetworkForward
		result2 string
		result3 error
	}
	GetNetworkForwardAddressesStub        func(string) ([]string, error)
	getNetworkForwardAddressesMutex       sync.RWMutex
	getNetworkForwardAddressesArgsForCall []struct {
		arg1 string
	}
	getNetworkForwardAddressesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkForwardAddressesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkForwardsStub        func(string) ([]api.NetworkForward, error)
	getNetworkForwardsMutex       sync.RWMutex
	getNetworkForwardsArgsForCall []struct {
		arg1 string
	}
	getNetworkForwardsReturns struct {
		result1 []api.NetworkForward
		result2 error
	}
	getNetworkForwardsReturnsOnCall map[int]struct {
		result1 []api.NetworkForward
		result2 error
	}
	GetNetworkLeasesStub        func(string) ([]api.NetworkLease, error)
	getNetworkLeasesMutex       sync.RWMutex
	getNetworkLeasesArgsForCall []struct {
		arg1 string
	}
	getNetworkLeasesReturns struct {
		result1 []api.NetworkLease
		result2 error
	}
	getNetworkLeasesReturnsOnCall map[int]struct {
		result1 []api.NetworkLease
		result2 error
	}
	GetNetworkLoadBalancerStub        func(string, string) (*api.NetworkLoadBalancer, string, error)
	getNetworkLoadBalancerMutex       sync.RWMutex
	getNetworkLoadBalancerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getNetworkLoadBalancerReturns struct {
		result1 *api.NetworkLoadBalancer
		result2 string
		result3 error
	}
	getNetworkLoadBalancerReturnsOnCall map[int]struct {
		result1 *api.NetworkLoadBalancer
		result2 string
		result3 error
	}
	GetNetworkLoadBalancerAddressesStub        func(string) ([]string, error)
	getNetworkLoadBalancerAddressesMutex       sync.RWMutex
	getNetworkLoadBalancerAddressesArgsForCall []struct {
		arg1 string
	}
	getNetworkLoadBalancerAddressesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkLoadBalancerAddressesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkLoadBalancersStub        func(string) ([]api.NetworkLoadBalancer, error)
	getNetworkLoadBalancersMutex       sync.RWMutex
	getNetworkLoadBalancersArgsForCall []struct {
		arg1 string
	}
	getNetworkLoadBalancersReturns struct {
		result1 []api.NetworkLoadBalancer
		result2 error
	}
	getNetworkLoadBalancersReturnsOnCall map[int]struct {
		result1 []api.NetworkLoadBalancer
		result2 error
	}
	GetNetworkNamesStub        func() ([]string, error)
	getNetworkNamesMutex       sync.RWMutex
	getNetworkNamesArgsForCall []struct {
	}
	getNetworkNamesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkPeerStub        func(string, string) (*api.NetworkPeer, string, error)
	getNetworkPeerMutex       sync.RWMutex
	getNetworkPeerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getNetworkPeerReturns struct {
		result1 *api.NetworkPeer
		result2 string
		result3 error
	}
	getNetworkPeerReturnsOnCall map[int]struct {
		result1 *api.NetworkPeer
		result2 string
		result3 error
	}
	GetNetworkPeerNamesStub        func(string) ([]string, error)
	getNetworkPeerNamesMutex       sync.RWMutex
	getNetworkPeerNamesArgsForCall []struct {
		arg1 string
	}
	getNetworkPeerNamesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkPeerNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkPeersStub        func(string) ([]api.NetworkPeer, error)
	getNetworkPeersMutex       sync.RWMutex
	getNetworkPeersArgsForCall []struct {
		arg1 string
	}
	getNetworkPeersReturns struct {
		result1 []api.NetworkPeer
		result2 error
	}
	getNetworkPeersReturnsOnCall map[int]struct {
		result1 []api.NetworkPeer
		result2 error
	}
	GetNetworkStateStub        func(string) (*api.NetworkState, error)
	getNetworkStateMutex       sync.RWMutex
	getNetworkStateArgsForCall []struct {
		arg1 string
	}
	getNetworkStateReturns struct {
		result1 *api.NetworkState
		result2 error
	}
	getNetworkStateReturnsOnCall map[int]struct {
		result1 *api.NetworkState
		result2 error
	}
	GetNetworkZoneStub        func(string) (*api.NetworkZone, string, error)
	getNetworkZoneMutex       sync.RWMutex
	getNetworkZoneArgsForCall []struct {
		arg1 string
	}
	getNetworkZoneReturns struct {
		result1 *api.NetworkZone
		result2 string
		result3 error
	}
	getNetworkZoneReturnsOnCall map[int]struct {
		result1 *api.NetworkZone
		result2 string
		result3 error
	}
	GetNetworkZoneNamesStub        func() ([]string, error)
	getNetworkZoneNamesMutex       sync.RWMutex
	getNetworkZoneNamesArgsForCall []struct {
	}
	getNetworkZoneNamesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkZoneNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkZoneRecordStub        func(string, string) (*api.NetworkZoneRecord, string, error)
	getNetworkZoneRecordMutex       sync.RWMutex
	getNetworkZoneRecordArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getNetworkZoneRecordReturns struct {
		result1 *api.NetworkZoneRecord
		result2 string
		result3 error
	}
	getNetworkZoneRecordReturnsOnCall map[int]struct {
		result1 *api.NetworkZoneRecord
		result2 string
		result3 error
	}
	GetNetworkZoneRecordNamesStub        func(string) ([]string, error)
	getNetworkZoneRecordNamesMutex       sync.RWMutex
	getNetworkZoneRecordNamesArgsForCall []struct {
		arg1 string
	}
	getNetworkZoneRecordNamesReturns struct {
		result1 []string
		result2 error
	}
	getNetworkZoneRecordNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetNetworkZoneRecordsStub        func(string) ([]api.NetworkZoneRecord, error)
	getNetworkZoneRecordsMutex       sync.RWMutex
	getNetworkZoneRecordsArgsForCall []struct {
		arg1 string
	}
	getNetworkZoneRecordsReturns struct {
		result1 []api.NetworkZoneRecord
		result2 error
	}
	getNetworkZoneRecordsReturnsOnCall map[int]struct {
		result1 []api.NetworkZoneRecord
		result2 error
	}
	GetNetworkZonesStub        func() ([]api.NetworkZone, error)
	getNetworkZonesMutex       sync.RWMutex
	getNetworkZonesArgsForCall []struct {
	}
	getNetworkZonesReturns struct {
		result1 []api.NetworkZone
		result2 error
	}
	getNetworkZonesReturnsOnCall map[int]struct {
		result1 []api.NetworkZone
		result2 error
	}
	GetNetworksStub        func() ([]api.Network, error)
	getNetworksMutex       sync.RWMutex
	getNetworksArgsForCall []struct {
	}
	getNetworksReturns struct {
		result1 []api.Network
		result2 error
	}
	getNetworksReturnsOnCall map[int]struct {
		result1 []api.Network
		result2 error
	}
	GetOperationStub        func(string) (*api.Operation, string, error)
	getOperationMutex       sync.RWMutex
	getOperationArgsForCall []struct {
		arg1 string
	}
	getOperationReturns struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	getOperationReturnsOnCall map[int]struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	GetOperationUUIDsStub        func() ([]string, error)
	getOperationUUIDsMutex       sync.RWMutex
	getOperationUUIDsArgsForCall []struct {
	}
	getOperationUUIDsReturns struct {
		result1 []string
		result2 error
	}
	getOperationUUIDsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetOperationWaitStub        func(string, int) (*api.Operation, string, error)
	getOperationWaitMutex       sync.RWMutex
	getOperationWaitArgsForCall []struct {
		arg1 string
		arg2 int
	}
	getOperationWaitReturns struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	getOperationWaitReturnsOnCall map[int]struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	GetOperationWaitSecretStub        func(string, string, int) (*api.Operation, string, error)
	getOperationWaitSecretMutex       sync.RWMutex
	getOperationWaitSecretArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 int
	}
	getOperationWaitSecretReturns struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	getOperationWaitSecretReturnsOnCall map[int]struct {
		result1 *api.Operation
		result2 string
		result3 error
	}
	GetOperationWebsocketStub        func(string, string) (*websocket.Conn, error)
	getOperationWebsocketMutex       sync.RWMutex
	getOperationWebsocketArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getOperationWebsocketReturns struct {
		result1 *websocket.Conn
		result2 error
	}
	getOperationWebsocketReturnsOnCall map[int]struct {
		result1 *websocket.Conn
		result2 error
	}
	GetOperationsStub        func() ([]api.Operation, error)
	getOperationsMutex       sync.RWMutex
	getOperationsArgsForCall []struct {
	}
	getOperationsReturns struct {
		result1 []api.Operation
		result2 error
	}
	getOperationsReturnsOnCall map[int]struct {
		result1 []api.Operation
		result2 error
	}
	GetPrivateImageStub        func(string, string) (*api.Image, string, error)
	getPrivateImageMutex       sync.RWMutex
	getPrivateImageArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getPrivateImageReturns struct {
		result1 *api.Image
		result2 string
		result3 error
	}
	getPrivateImageReturnsOnCall map[int]struct {
		result1 *api.Image
		result2 string
		result3 error
	}
	GetPrivateImageFileStub        func(string, string, lxd.ImageFileRequest) (*lxd.ImageFileResponse, error)
	getPrivateImageFileMutex       sync.RWMutex
	getPrivateImageFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 lxd.ImageFileRequest
	}
	getPrivateImageFileReturns struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}
	getPrivateImageFileReturnsOnCall map[int]struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}
	GetProfileStub        func(string) (*api.Profile, string, error)
	getProfileMutex       sync.RWMutex
	getProfileArgsForCall []struct {
		arg1 string
	}
	getProfileReturns struct {
		result1 *api.Profile
		result2 string
		result3 error
	}
	getProfileReturnsOnCall map[int]struct {
		result1 *api.Profile
		result2 string
		result3 error
	}
	GetProfileNamesStub        func() ([]string, error)
	getProfileNamesMutex       sync.RWMutex
	getProfileNamesArgsForCall []struct {
	}
	getProfileNamesReturns struct {
		result1 []string
		result2 error
	}
	getProfileNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetProfilesStub        func() ([]api.Profile, error)
	getProfilesMutex       sync.RWMutex
	getProfilesArgsForCall []struct {
	}
	getProfilesReturns struct {
		result1 []api.Profile
		result2 error
	}
	getProfilesReturnsOnCall map[int]struct {
		result1 []api.Profile
		result2 error
	}
	GetProjectStub        func(string) (*api.Project, string, error)
	getProjectMutex       sync.RWMutex
	getProjectArgsForCall []struct {
		arg1 string
	}
	getProjectReturns struct {
		result1 *api.Project
		result2 string
		result3 error
	}
	getProjectReturnsOnCall map[int]struct {
		result1 *api.Project
		result2 string
		result3 error
	}
	GetProjectNamesStub        func() ([]string, error)
	getProjectNamesMutex       sync.RWMutex
	getProjectNamesArgsForCall []struct {
	}
	getProjectNamesReturns struct {
		result1 []string
		result2 error
	}
	getProjectNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetProjectStateStub        func(string) (*api.ProjectState, error)
	getProjectStateMutex       sync.RWMutex
	getProjectStateArgsForCall []struct {
		arg1 string
	}
	getProjectStateReturns struct {
		result1 *api.ProjectState
		result2 error
	}
	getProjectStateReturnsOnCall map[int]struct {
		result1 *api.ProjectState
		result2 error
	}
	GetProjectsStub        func() ([]api.Project, error)
	getProjectsMutex       sync.RWMutex
	getProjectsArgsForCall []struct {
	}
	getProjectsReturns struct {
		result1 []api.Project
		result2 error
	}
	getProjectsReturnsOnCall map[int]struct {
		result1 []api.Project
		result2 error
	}
	GetServerStub        func() (*api.Server, string, error)
	getServerMutex       sync.RWMutex
	getServerArgsForCall []struct {
	}
	getServerReturns struct {
		result1 *api.Server
		result2 string
		result3 error
	}
	getServerReturnsOnCall map[int]struct {
		result1 *api.Server
		result2 string
		result3 error
	}
	GetServerResourcesStub        func() (*api.Resources, error)
	getServerResourcesMutex       sync.RWMutex
	getServerResourcesArgsForCall []struct {
	}
	getServerResourcesReturns struct {
		result1 *api.Resources
		result2 error
	}
	getServerResourcesReturnsOnCall map[int]struct {
		result1 *api.Resources
		result2 error
	}
	GetStoragePoolStub        func(string) (*api.StoragePool, string, error)
	getStoragePoolMutex       sync.RWMutex
	getStoragePoolArgsForCall []struct {
		arg1 string
	}
	getStoragePoolReturns struct {
		result1 *api.StoragePool
		result2 string
		result3 error
	}
	getStoragePoolReturnsOnCall map[int]struct {
		result1 *api.StoragePool
		result2 string
		result3 error
	}
	GetStoragePoolNamesStub        func() ([]string, error)
	getStoragePoolNamesMutex       sync.RWMutex
	getStoragePoolNamesArgsForCall []struct {
	}
	getStoragePoolNamesReturns struct {
		result1 []string
		result2 error
	}
	getStoragePoolNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetStoragePoolResourcesStub        func(string) (*api.ResourcesStoragePool, error)
	getStoragePoolResourcesMutex       sync.RWMutex
	getStoragePoolResourcesArgsForCall []struct {
		arg1 string
	}
	getStoragePoolResourcesReturns struct {
		result1 *api.ResourcesStoragePool
		result2 error
	}
	getStoragePoolResourcesReturnsOnCall map[int]struct {
		result1 *api.ResourcesStoragePool
		result2 error
	}
	GetStoragePoolVolumeStub        func(string, string, string) (*api.StorageVolume, string, error)
	getStoragePoolVolumeMutex       sync.RWMutex
	getStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getStoragePoolVolumeReturns struct {
		result1 *api.StorageVolume
		result2 string
		result3 error
	}
	getStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 *api.StorageVolume
		result2 string
		result3 error
	}
	GetStoragePoolVolumeBackupStub        func(string, string, string) (*api.StoragePoolVolumeBackup, string, error)
	getStoragePoolVolumeBackupMutex       sync.RWMutex
	getStoragePoolVolumeBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getStoragePoolVolumeBackupReturns struct {
		result1 *api.StoragePoolVolumeBackup
		result2 string
		result3 error
	}
	getStoragePoolVolumeBackupReturnsOnCall map[int]struct {
		result1 *api.StoragePoolVolumeBackup
		result2 string
		result3 error
	}
	GetStoragePoolVolumeBackupFileStub        func(string, string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)
	getStoragePoolVolumeBackupFileMutex       sync.RWMutex
	getStoragePoolVolumeBackupFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 *lxd.BackupFileRequest
	}
	getStoragePoolVolumeBackupFileReturns struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	getStoragePoolVolumeBackupFileReturnsOnCall map[int]struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}
	GetStoragePoolVolumeBackupNamesStub        func(string, string) ([]string, error)
	getStoragePoolVolumeBackupNamesMutex       sync.RWMutex
	getStoragePoolVolumeBackupNamesArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getStoragePoolVolumeBackupNamesReturns struct {
		result1 []string
		result2 error
	}
	getStoragePoolVolumeBackupNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetStoragePoolVolumeBackupsStub        func(string, string) ([]api.StoragePoolVolumeBackup, error)
	getStoragePoolVolumeBackupsMutex       sync.RWMutex
	getStoragePoolVolumeBackupsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getStoragePoolVolumeBackupsReturns struct {
		result1 []api.StoragePoolVolumeBackup
		result2 error
	}
	getStoragePoolVolumeBackupsReturnsOnCall map[int]struct {
		result1 []api.StoragePoolVolumeBackup
		result2 error
	}
	GetStoragePoolVolumeNamesStub        func(string) ([]string, error)
	getStoragePoolVolumeNamesMutex       sync.RWMutex
	getStoragePoolVolumeNamesArgsForCall []struct {
		arg1 string
	}
	getStoragePoolVolumeNamesReturns struct {
		result1 []string
		result2 error
	}
	getStoragePoolVolumeNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetStoragePoolVolumeNamesAllProjectsStub        func(string) ([]string, error)
	getStoragePoolVolumeNamesAllProjectsMutex       sync.RWMutex
	getStoragePoolVolumeNamesAllProjectsArgsForCall []struct {
		arg1 string
	}
	getStoragePoolVolumeNamesAllProjectsReturns struct {
		result1 []string
		result2 error
	}
	getStoragePoolVolumeNamesAllProjectsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetStoragePoolVolumeSnapshotStub        func(string, string, string, string) (*api.StorageVolumeSnapshot, string, error)
	getStoragePoolVolumeSnapshotMutex       sync.RWMutex
	getStoragePoolVolumeSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}
	getStoragePoolVolumeSnapshotReturns struct {
		result1 *api.StorageVolumeSnapshot
		result2 string
		result3 error
	}
	getStoragePoolVolumeSnapshotReturnsOnCall map[int]struct {
		result1 *api.StorageVolumeSnapshot
		result2 string
		result3 error
	}
	GetStoragePoolVolumeSnapshotNamesStub        func(string, string, string) ([]string, error)
	getStoragePoolVolumeSnapshotNamesMutex       sync.RWMutex
	getStoragePoolVolumeSnapshotNamesArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getStoragePoolVolumeSnapshotNamesReturns struct {
		result1 []string
		result2 error
	}
	getStoragePoolVolumeSnapshotNamesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetStoragePoolVolumeSnapshotsStub        func(string, string, string) ([]api.StorageVolumeSnapshot, error)
	getStoragePoolVolumeSnapshotsMutex       sync.RWMutex
	getStoragePoolVolumeSnapshotsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getStoragePoolVolumeSnapshotsReturns struct {
		result1 []api.StorageVolumeSnapshot
		result2 error
	}
	getStoragePoolVolumeSnapshotsReturnsOnCall map[int]struct {
		result1 []api.StorageVolumeSnapshot
		result2 error
	}
	GetStoragePoolVolumeStateStub        func(string, string, string) (*api.StorageVolumeState, error)
	getStoragePoolVolumeStateMutex       sync.RWMutex
	getStoragePoolVolumeStateArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getStoragePoolVolumeStateReturns struct {
		result1 *api.StorageVolumeState
		result2 error
	}
	getStoragePoolVolumeStateReturnsOnCall map[int]struct {
		result1 *api.StorageVolumeState
		result2 error
	}
	GetStoragePoolVolumesStub        func(string) ([]api.StorageVolume, error)
	getStoragePoolVolumesMutex       sync.RWMutex
	getStoragePoolVolumesArgsForCall []struct {
		arg1 string
	}
	getStoragePoolVolumesReturns struct {
		result1 []api.StorageVolume
		result2 error
	}
	getStoragePoolVolumesReturnsOnCall map[int]struct {
		result1 []api.StorageVolume
		result2 error
	}
	GetStoragePoolVolumesAllProjectsStub        func(string) ([]api.StorageVolume, error)
	getStoragePoolVolumesAllProjectsMutex       sync.RWMutex
	getStoragePoolVolumesAllProjectsArgsForCall []struct {
		arg1 string
	}
	getStoragePoolVolumesAllProjectsReturns struct {
		result1 []api.StorageVolume
		result2 error
	}
	getStoragePoolVolumesAllProjectsReturnsOnCall map[int]struct {
		result1 []api.StorageVolume
		result2 error
	}
	GetStoragePoolVolumesWithFilterStub        func(string, []string) ([]api.StorageVolume, error)
	getStoragePoolVolumesWithFilterMutex       sync.RWMutex
	getStoragePoolVolumesWithFilterArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	getStoragePoolVolumesWithFilterReturns struct {
		result1 []api.StorageVolume
		result2 error
	}
	getStoragePoolVolumesWithFilterReturnsOnCall map[int]struct {
		result1 []api.StorageVolume
		result2 error
	}
	GetStoragePoolVolumesWithFilterAllProjectsStub        func(string, []string) ([]api.StorageVolume, error)
	getStoragePoolVolumesWithFilterAllProjectsMutex       sync.RWMutex
	getStoragePoolVolumesWithFilterAllProjectsArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	getStoragePoolVolumesWithFilterAllProjectsReturns struct {
		result1 []api.StorageVolume
		result2 error
	}
	getStoragePoolVolumesWithFilterAllProjectsReturnsOnCall map[int]struct {
		result1 []api.StorageVolume
		result2 error
	}
	GetStoragePoolsStub        func() ([]api.StoragePool, error)
	getStoragePoolsMutex       sync.RWMutex
	getStoragePoolsArgsForCall []struct {
	}
	getStoragePoolsReturns struct {
		result1 []api.StoragePool
		result2 error
	}
	getStoragePoolsReturnsOnCall map[int]struct {
		result1 []api.StoragePool
		result2 error
	}
	GetWarningStub        func(string) (*api.Warning, string, error)
	getWarningMutex       sync.RWMutex
	getWarningArgsForCall []struct {
		arg1 string
	}
	getWarningReturns struct {
		result1 *api.Warning
		result2 string
		result3 error
	}
	getWarningReturnsOnCall map[int]struct {
		result1 *api.Warning
		result2 string
		result3 error
	}
	GetWarningUUIDsStub        func() ([]string, error)
	getWarningUUIDsMutex       sync.RWMutex
	getWarningUUIDsArgsForCall []struct {
	}
	getWarningUUIDsReturns struct {
		result1 []string
		result2 error
	}
	getWarningUUIDsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetWarningsStub        func() ([]api.Warning, error)
	getWarningsMutex       sync.RWMutex
	getWarningsArgsForCall []struct {
	}
	getWarningsReturns struct {
		result1 []api.Warning
		result2 error
	}
	getWarningsReturnsOnCall map[int]struct {
		result1 []api.Warning
		result2 error
	}
	HasExtensionStub        func(string) bool
	hasExtensionMutex       sync.RWMutex
	hasExtensionArgsForCall []struct {
		arg1 string
	}
	hasExtensionReturns struct {
		result1 bool
	}
	hasExtensionReturnsOnCall map[int]struct {
		result1 bool
	}
	IsClusteredStub        func() bool
	isClusteredMutex       sync.RWMutex
	isClusteredArgsForCall []struct {
	}
	isClusteredReturns struct {
		result1 bool
	}
	isClusteredReturnsOnCall map[int]struct {
		result1 bool
	}
	MigrateContainerStub        func(string, api.ContainerPost) (lxd.Operation, error)
	migrateContainerMutex       sync.RWMutex
	migrateContainerArgsForCall []struct {
		arg1 string
		arg2 api.ContainerPost
	}
	migrateContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	migrateContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	MigrateContainerSnapshotStub        func(string, string, api.ContainerSnapshotPost) (lxd.Operation, error)
	migrateContainerSnapshotMutex       sync.RWMutex
	migrateContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPost
	}
	migrateContainerSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	migrateContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	MigrateInstanceStub        func(string, api.InstancePost) (lxd.Operation, error)
	migrateInstanceMutex       sync.RWMutex
	migrateInstanceArgsForCall []struct {
		arg1 string
		arg2 api.InstancePost
	}
	migrateInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	migrateInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	MigrateInstanceSnapshotStub        func(string, string, api.InstanceSnapshotPost) (lxd.Operation, error)
	migrateInstanceSnapshotMutex       sync.RWMutex
	migrateInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPost
	}
	migrateInstanceSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	migrateInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	MigrateStoragePoolVolumeStub        func(string, api.StorageVolumePost) (lxd.Operation, error)
	migrateStoragePoolVolumeMutex       sync.RWMutex
	migrateStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 api.StorageVolumePost
	}
	migrateStoragePoolVolumeReturns struct {
		result1 lxd.Operation
		result2 error
	}
	migrateStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	MoveStoragePoolVolumeStub        func(string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeMoveArgs) (lxd.RemoteOperation, error)
	moveStoragePoolVolumeMutex       sync.RWMutex
	moveStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 lxd.InstanceServer
		arg3 string
		arg4 api.StorageVolume
		arg5 *lxd.StoragePoolVolumeMoveArgs
	}
	moveStoragePoolVolumeReturns struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	moveStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 lxd.RemoteOperation
		result2 error
	}
	RawOperationStub        func(string, string, any, string) (lxd.Operation, string, error)
	rawOperationMutex       sync.RWMutex
	rawOperationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 any
		arg4 string
	}
	rawOperationReturns struct {
		result1 lxd.Operation
		result2 string
		result3 error
	}
	rawOperationReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 string
		result3 error
	}
	RawQueryStub        func(string, string, any, string) (*api.Response, string, error)
	rawQueryMutex       sync.RWMutex
	rawQueryArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 any
		arg4 string
	}
	rawQueryReturns struct {
		result1 *api.Response
		result2 string
		result3 error
	}
	rawQueryReturnsOnCall map[int]struct {
		result1 *api.Response
		result2 string
		result3 error
	}
	RawWebsocketStub        func(string) (*websocket.Conn, error)
	rawWebsocketMutex       sync.RWMutex
	rawWebsocketArgsForCall []struct {
		arg1 string
	}
	rawWebsocketReturns struct {
		result1 *websocket.Conn
		result2 error
	}
	rawWebsocketReturnsOnCall map[int]struct {
		result1 *websocket.Conn
		result2 error
	}
	RefreshImageStub        func(string) (lxd.Operation, error)
	refreshImageMutex       sync.RWMutex
	refreshImageArgsForCall []struct {
		arg1 string
	}
	refreshImageReturns struct {
		result1 lxd.Operation
		result2 error
	}
	refreshImageReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameClusterGroupStub        func(string, api.ClusterGroupPost) error
	renameClusterGroupMutex       sync.RWMutex
	renameClusterGroupArgsForCall []struct {
		arg1 string
		arg2 api.ClusterGroupPost
	}
	renameClusterGroupReturns struct {
		result1 error
	}
	renameClusterGroupReturnsOnCall map[int]struct {
		result1 error
	}
	RenameClusterMemberStub        func(string, api.ClusterMemberPost) error
	renameClusterMemberMutex       sync.RWMutex
	renameClusterMemberArgsForCall []struct {
		arg1 string
		arg2 api.ClusterMemberPost
	}
	renameClusterMemberReturns struct {
		result1 error
	}
	renameClusterMemberReturnsOnCall map[int]struct {
		result1 error
	}
	RenameContainerStub        func(string, api.ContainerPost) (lxd.Operation, error)
	renameContainerMutex       sync.RWMutex
	renameContainerArgsForCall []struct {
		arg1 string
		arg2 api.ContainerPost
	}
	renameContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameContainerBackupStub        func(string, string, api.ContainerBackupPost) (lxd.Operation, error)
	renameContainerBackupMutex       sync.RWMutex
	renameContainerBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.ContainerBackupPost
	}
	renameContainerBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameContainerBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameContainerSnapshotStub        func(string, string, api.ContainerSnapshotPost) (lxd.Operation, error)
	renameContainerSnapshotMutex       sync.RWMutex
	renameContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPost
	}
	renameContainerSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameImageAliasStub        func(string, api.ImageAliasesEntryPost) error
	renameImageAliasMutex       sync.RWMutex
	renameImageAliasArgsForCall []struct {
		arg1 string
		arg2 api.ImageAliasesEntryPost
	}
	renameImageAliasReturns struct {
		result1 error
	}
	renameImageAliasReturnsOnCall map[int]struct {
		result1 error
	}
	RenameInstanceStub        func(string, api.InstancePost) (lxd.Operation, error)
	renameInstanceMutex       sync.RWMutex
	renameInstanceArgsForCall []struct {
		arg1 string
		arg2 api.InstancePost
	}
	renameInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameInstanceBackupStub        func(string, string, api.InstanceBackupPost) (lxd.Operation, error)
	renameInstanceBackupMutex       sync.RWMutex
	renameInstanceBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.InstanceBackupPost
	}
	renameInstanceBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameInstanceBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameInstanceSnapshotStub        func(string, string, api.InstanceSnapshotPost) (lxd.Operation, error)
	renameInstanceSnapshotMutex       sync.RWMutex
	renameInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPost
	}
	renameInstanceSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameNetworkStub        func(string, api.NetworkPost) error
	renameNetworkMutex       sync.RWMutex
	renameNetworkArgsForCall []struct {
		arg1 string
		arg2 api.NetworkPost
	}
	renameNetworkReturns struct {
		result1 error
	}
	renameNetworkReturnsOnCall map[int]struct {
		result1 error
	}
	RenameNetworkACLStub        func(string, api.NetworkACLPost) error
	renameNetworkACLMutex       sync.RWMutex
	renameNetworkACLArgsForCall []struct {
		arg1 string
		arg2 api.NetworkACLPost
	}
	renameNetworkACLReturns struct {
		result1 error
	}
	renameNetworkACLReturnsOnCall map[int]struct {
		result1 error
	}
	RenameProfileStub        func(string, api.ProfilePost) error
	renameProfileMutex       sync.RWMutex
	renameProfileArgsForCall []struct {
		arg1 string
		arg2 api.ProfilePost
	}
	renameProfileReturns struct {
		result1 error
	}
	renameProfileReturnsOnCall map[int]struct {
		result1 error
	}
	RenameProjectStub        func(string, api.ProjectPost) (lxd.Operation, error)
	renameProjectMutex       sync.RWMutex
	renameProjectArgsForCall []struct {
		arg1 string
		arg2 api.ProjectPost
	}
	renameProjectReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameProjectReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameStoragePoolVolumeStub        func(string, string, string, api.StorageVolumePost) error
	renameStoragePoolVolumeMutex       sync.RWMutex
	renameStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumePost
	}
	renameStoragePoolVolumeReturns struct {
		result1 error
	}
	renameStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	RenameStoragePoolVolumeBackupStub        func(string, string, string, api.StoragePoolVolumeBackupPost) (lxd.Operation, error)
	renameStoragePoolVolumeBackupMutex       sync.RWMutex
	renameStoragePoolVolumeBackupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StoragePoolVolumeBackupPost
	}
	renameStoragePoolVolumeBackupReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameStoragePoolVolumeBackupReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RenameStoragePoolVolumeSnapshotStub        func(string, string, string, string, api.StorageVolumeSnapshotPost) (lxd.Operation, error)
	renameStoragePoolVolumeSnapshotMutex       sync.RWMutex
	renameStoragePoolVolumeSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 api.StorageVolumeSnapshotPost
	}
	renameStoragePoolVolumeSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	renameStoragePoolVolumeSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	RequireAuthenticatedStub        func(bool)
	requireAuthenticatedMutex       sync.RWMutex
	requireAuthenticatedArgsForCall []struct {
		arg1 bool
	}
	SendEventStub        func(api.Event) error
	sendEventMutex       sync.RWMutex
	sendEventArgsForCall []struct {
		arg1 api.Event
	}
	sendEventReturns struct {
		result1 error
	}
	sendEventReturnsOnCall map[int]struct {
		result1 error
	}
	SetContainerMetadataStub        func(string, api.ImageMetadata, string) error
	setContainerMetadataMutex       sync.RWMutex
	setContainerMetadataArgsForCall []struct {
		arg1 string
		arg2 api.ImageMetadata
		arg3 string
	}
	setContainerMetadataReturns struct {
		result1 error
	}
	setContainerMetadataReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateCertificateStub        func(string, api.CertificatePut, string) error
	updateCertificateMutex       sync.RWMutex
	updateCertificateArgsForCall []struct {
		arg1 string
		arg2 api.CertificatePut
		arg3 string
	}
	updateCertificateReturns struct {
		result1 error
	}
	updateCertificateReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateClusterStub        func(api.ClusterPut, string) (lxd.Operation, error)
	updateClusterMutex       sync.RWMutex
	updateClusterArgsForCall []struct {
		arg1 api.ClusterPut
		arg2 string
	}
	updateClusterReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateClusterReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateClusterCertificateStub        func(api.ClusterCertificatePut, string) error
	updateClusterCertificateMutex       sync.RWMutex
	updateClusterCertificateArgsForCall []struct {
		arg1 api.ClusterCertificatePut
		arg2 string
	}
	updateClusterCertificateReturns struct {
		result1 error
	}
	updateClusterCertificateReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateClusterGroupStub        func(string, api.ClusterGroupPut, string) error
	updateClusterGroupMutex       sync.RWMutex
	updateClusterGroupArgsForCall []struct {
		arg1 string
		arg2 api.ClusterGroupPut
		arg3 string
	}
	updateClusterGroupReturns struct {
		result1 error
	}
	updateClusterGroupReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateClusterMemberStub        func(string, api.ClusterMemberPut, string) error
	updateClusterMemberMutex       sync.RWMutex
	updateClusterMemberArgsForCall []struct {
		arg1 string
		arg2 api.ClusterMemberPut
		arg3 string
	}
	updateClusterMemberReturns struct {
		result1 error
	}
	updateClusterMemberReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateClusterMemberStateStub        func(string, api.ClusterMemberStatePost) (lxd.Operation, error)
	updateClusterMemberStateMutex       sync.RWMutex
	updateClusterMemberStateArgsForCall []struct {
		arg1 string
		arg2 api.ClusterMemberStatePost
	}
	updateClusterMemberStateReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateClusterMemberStateReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateContainerStub        func(string, api.ContainerPut, string) (lxd.Operation, error)
	updateContainerMutex       sync.RWMutex
	updateContainerArgsForCall []struct {
		arg1 string
		arg2 api.ContainerPut
		arg3 string
	}
	updateContainerReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateContainerReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateContainerSnapshotStub        func(string, string, api.ContainerSnapshotPut, string) (lxd.Operation, error)
	updateContainerSnapshotMutex       sync.RWMutex
	updateContainerSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPut
		arg4 string
	}
	updateContainerSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateContainerSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateContainerStateStub        func(string, api.ContainerStatePut, string) (lxd.Operation, error)
	updateContainerStateMutex       sync.RWMutex
	updateContainerStateArgsForCall []struct {
		arg1 string
		arg2 api.ContainerStatePut
		arg3 string
	}
	updateContainerStateReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateContainerStateReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateContainerTemplateFileStub        func(string, string, io.ReadSeeker) error
	updateContainerTemplateFileMutex       sync.RWMutex
	updateContainerTemplateFileArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}
	updateContainerTemplateFileReturns struct {
		result1 error
	}
	updateContainerTemplateFileReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateImageStub        func(string, api.ImagePut, string) error
	updateImageMutex       sync.RWMutex
	updateImageArgsForCall []struct {
		arg1 string
		arg2 api.ImagePut
		arg3 string
	}
	updateImageReturns struct {
		result1 error
	}
	updateImageReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateImageAliasStub        func(string, api.ImageAliasesEntryPut, string) error
	updateImageAliasMutex       sync.RWMutex
	updateImageAliasArgsForCall []struct {
		arg1 string
		arg2 api.ImageAliasesEntryPut
		arg3 string
	}
	updateImageAliasReturns struct {
		result1 error
	}
	updateImageAliasReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateInstanceStub        func(string, api.InstancePut, string) (lxd.Operation, error)
	updateInstanceMutex       sync.RWMutex
	updateInstanceArgsForCall []struct {
		arg1 string
		arg2 api.InstancePut
		arg3 string
	}
	updateInstanceReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateInstanceReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateInstanceMetadataStub        func(string, api.ImageMetadata, string) error
	updateInstanceMetadataMutex       sync.RWMutex
	updateInstanceMetadataArgsForCall []struct {
		arg1 string
		arg2 api.ImageMetadata
		arg3 string
	}
	updateInstanceMetadataReturns struct {
		result1 error
	}
	updateInstanceMetadataReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateInstanceSnapshotStub        func(string, string, api.InstanceSnapshotPut, string) (lxd.Operation, error)
	updateInstanceSnapshotMutex       sync.RWMutex
	updateInstanceSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPut
		arg4 string
	}
	updateInstanceSnapshotReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateInstanceSnapshotReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateInstanceStateStub        func(string, api.InstanceStatePut, string) (lxd.Operation, error)
	updateInstanceStateMutex       sync.RWMutex
	updateInstanceStateArgsForCall []struct {
		arg1 string
		arg2 api.InstanceStatePut
		arg3 string
	}
	updateInstanceStateReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateInstanceStateReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateInstancesStub        func(api.InstancesPut, string) (lxd.Operation, error)
	updateInstancesMutex       sync.RWMutex
	updateInstancesArgsForCall []struct {
		arg1 api.InstancesPut
		arg2 string
	}
	updateInstancesReturns struct {
		result1 lxd.Operation
		result2 error
	}
	updateInstancesReturnsOnCall map[int]struct {
		result1 lxd.Operation
		result2 error
	}
	UpdateNetworkStub        func(string, api.NetworkPut, string) error
	updateNetworkMutex       sync.RWMutex
	updateNetworkArgsForCall []struct {
		arg1 string
		arg2 api.NetworkPut
		arg3 string
	}
	updateNetworkReturns struct {
		result1 error
	}
	updateNetworkReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkACLStub        func(string, api.NetworkACLPut, string) error
	updateNetworkACLMutex       sync.RWMutex
	updateNetworkACLArgsForCall []struct {
		arg1 string
		arg2 api.NetworkACLPut
		arg3 string
	}
	updateNetworkACLReturns struct {
		result1 error
	}
	updateNetworkACLReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkForwardStub        func(string, string, api.NetworkForwardPut, string) error
	updateNetworkForwardMutex       sync.RWMutex
	updateNetworkForwardArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.NetworkForwardPut
		arg4 string
	}
	updateNetworkForwardReturns struct {
		result1 error
	}
	updateNetworkForwardReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkLoadBalancerStub        func(string, string, api.NetworkLoadBalancerPut, string) error
	updateNetworkLoadBalancerMutex       sync.RWMutex
	updateNetworkLoadBalancerArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.NetworkLoadBalancerPut
		arg4 string
	}
	updateNetworkLoadBalancerReturns struct {
		result1 error
	}
	updateNetworkLoadBalancerReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkPeerStub        func(string, string, api.NetworkPeerPut, string) error
	updateNetworkPeerMutex       sync.RWMutex
	updateNetworkPeerArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.NetworkPeerPut
		arg4 string
	}
	updateNetworkPeerReturns struct {
		result1 error
	}
	updateNetworkPeerReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkZoneStub        func(string, api.NetworkZonePut, string) error
	updateNetworkZoneMutex       sync.RWMutex
	updateNetworkZoneArgsForCall []struct {
		arg1 string
		arg2 api.NetworkZonePut
		arg3 string
	}
	updateNetworkZoneReturns struct {
		result1 error
	}
	updateNetworkZoneReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNetworkZoneRecordStub        func(string, string, api.NetworkZoneRecordPut, string) error
	updateNetworkZoneRecordMutex       sync.RWMutex
	updateNetworkZoneRecordArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 api.NetworkZoneRecordPut
		arg4 string
	}
	updateNetworkZoneRecordReturns struct {
		result1 error
	}
	updateNetworkZoneRecordReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateProfileStub        func(string, api.ProfilePut, string) error
	updateProfileMutex       sync.RWMutex
	updateProfileArgsForCall []struct {
		arg1 string
		arg2 api.ProfilePut
		arg3 string
	}
	updateProfileReturns struct {
		result1 error
	}
	updateProfileReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateProjectStub        func(string, api.ProjectPut, string) error
	updateProjectMutex       sync.RWMutex
	updateProjectArgsForCall []struct {
		arg1 string
		arg2 api.ProjectPut
		arg3 string
	}
	updateProjectReturns struct {
		result1 error
	}
	updateProjectReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateServerStub        func(api.ServerPut, string) error
	updateServerMutex       sync.RWMutex
	updateServerArgsForCall []struct {
		arg1 api.ServerPut
		arg2 string
	}
	updateServerReturns struct {
		result1 error
	}
	updateServerReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateStoragePoolStub        func(string, api.StoragePoolPut, string) error
	updateStoragePoolMutex       sync.RWMutex
	updateStoragePoolArgsForCall []struct {
		arg1 string
		arg2 api.StoragePoolPut
		arg3 string
	}
	updateStoragePoolReturns struct {
		result1 error
	}
	updateStoragePoolReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateStoragePoolVolumeStub        func(string, string, string, api.StorageVolumePut, string) error
	updateStoragePoolVolumeMutex       sync.RWMutex
	updateStoragePoolVolumeArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumePut
		arg5 string
	}
	updateStoragePoolVolumeReturns struct {
		result1 error
	}
	updateStoragePoolVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateStoragePoolVolumeSnapshotStub        func(string, string, string, string, api.StorageVolumeSnapshotPut, string) error
	updateStoragePoolVolumeSnapshotMutex       sync.RWMutex
	updateStoragePoolVolumeSnapshotArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 api.StorageVolumeSnapshotPut
		arg6 string
	}
	updateStoragePoolVolumeSnapshotReturns struct {
		result1 error
	}
	updateStoragePoolVolumeSnapshotReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateWarningStub        func(string, api.WarningPut, string) error
	updateWarningMutex       sync.RWMutex
	updateWarningArgsForCall []struct {
		arg1 string
		arg2 api.WarningPut
		arg3 string
	}
	updateWarningReturns struct {
		result1 error
	}
	updateWarningReturnsOnCall map[int]struct {
		result1 error
	}
	UseProjectStub        func(string) lxd.InstanceServer
	useProjectMutex       sync.RWMutex
	useProjectArgsForCall []struct {
		arg1 string
	}
	useProjectReturns struct {
		result1 lxd.InstanceServer
	}
	useProjectReturnsOnCall map[int]struct {
		result1 lxd.InstanceServer
	}
	UseTargetStub        func(string) lxd.InstanceServer
	useTargetMutex       sync.RWMutex
	useTargetArgsForCall []struct {
		arg1 string
	}
	useTargetReturns struct {
		result1 lxd.InstanceServer
	}
	useTargetReturnsOnCall map[int]struct {
		result1 lxd.InstanceServer
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeContainerServer) ConsoleContainer(arg1 string, arg2 api.ContainerConsolePost, arg3 *lxd.ContainerConsoleArgs) (lxd.Operation, error) {
	fake.consoleContainerMutex.Lock()
	ret, specificReturn := fake.consoleContainerReturnsOnCall[len(fake.consoleContainerArgsForCall)]
	fake.consoleContainerArgsForCall = append(fake.consoleContainerArgsForCall, struct {
		arg1 string
		arg2 api.ContainerConsolePost
		arg3 *lxd.ContainerConsoleArgs
	}{arg1, arg2, arg3})
	stub := fake.ConsoleContainerStub
	fakeReturns := fake.consoleContainerReturns
	fake.recordInvocation("ConsoleContainer", []interface{}{arg1, arg2, arg3})
	fake.consoleContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) ConsoleContainerCallCount() int {
	fake.consoleContainerMutex.RLock()
	defer fake.consoleContainerMutex.RUnlock()
	return len(fake.consoleContainerArgsForCall)
}

func (fake *FakeContainerServer) ConsoleContainerCalls(stub func(string, api.ContainerConsolePost, *lxd.ContainerConsoleArgs) (lxd.Operation, error)) {
	fake.consoleContainerMutex.Lock()
	defer fake.consoleContainerMutex.Unlock()
	fake.ConsoleContainerStub = stub
}

func (fake *FakeContainerServer) ConsoleContainerArgsForCall(i int) (string, api.ContainerConsolePost, *lxd.ContainerConsoleArgs) {
	fake.consoleContainerMutex.RLock()
	defer fake.consoleContainerMutex.RUnlock()
	argsForCall := fake.consoleContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) ConsoleContainerReturns(result1 lxd.Operation, result2 error) {
	fake.consoleContainerMutex.Lock()
	defer fake.consoleContainerMutex.Unlock()
	fake.ConsoleContainerStub = nil
	fake.consoleContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ConsoleContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.consoleContainerMutex.Lock()
	defer fake.consoleContainerMutex.Unlock()
	fake.ConsoleContainerStub = nil
	if fake.consoleContainerReturnsOnCall == nil {
		fake.consoleContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.consoleContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ConsoleInstance(arg1 string, arg2 api.InstanceConsolePost, arg3 *lxd.InstanceConsoleArgs) (lxd.Operation, error) {
	fake.consoleInstanceMutex.Lock()
	ret, specificReturn := fake.consoleInstanceReturnsOnCall[len(fake.consoleInstanceArgsForCall)]
	fake.consoleInstanceArgsForCall = append(fake.consoleInstanceArgsForCall, struct {
		arg1 string
		arg2 api.InstanceConsolePost
		arg3 *lxd.InstanceConsoleArgs
	}{arg1, arg2, arg3})
	stub := fake.ConsoleInstanceStub
	fakeReturns := fake.consoleInstanceReturns
	fake.recordInvocation("ConsoleInstance", []interface{}{arg1, arg2, arg3})
	fake.consoleInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) ConsoleInstanceCallCount() int {
	fake.consoleInstanceMutex.RLock()
	defer fake.consoleInstanceMutex.RUnlock()
	return len(fake.consoleInstanceArgsForCall)
}

func (fake *FakeContainerServer) ConsoleInstanceCalls(stub func(string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) (lxd.Operation, error)) {
	fake.consoleInstanceMutex.Lock()
	defer fake.consoleInstanceMutex.Unlock()
	fake.ConsoleInstanceStub = stub
}

func (fake *FakeContainerServer) ConsoleInstanceArgsForCall(i int) (string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) {
	fake.consoleInstanceMutex.RLock()
	defer fake.consoleInstanceMutex.RUnlock()
	argsForCall := fake.consoleInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) ConsoleInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.consoleInstanceMutex.Lock()
	defer fake.consoleInstanceMutex.Unlock()
	fake.ConsoleInstanceStub = nil
	fake.consoleInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ConsoleInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.consoleInstanceMutex.Lock()
	defer fake.consoleInstanceMutex.Unlock()
	fake.ConsoleInstanceStub = nil
	if fake.consoleInstanceReturnsOnCall == nil {
		fake.consoleInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.consoleInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ConsoleInstanceDynamic(arg1 string, arg2 api.InstanceConsolePost, arg3 *lxd.InstanceConsoleArgs) (lxd.Operation, func(io.ReadWriteCloser) error, error) {
	fake.consoleInstanceDynamicMutex.Lock()
	ret, specificReturn := fake.consoleInstanceDynamicReturnsOnCall[len(fake.consoleInstanceDynamicArgsForCall)]
	fake.consoleInstanceDynamicArgsForCall = append(fake.consoleInstanceDynamicArgsForCall, struct {
		arg1 string
		arg2 api.InstanceConsolePost
		arg3 *lxd.InstanceConsoleArgs
	}{arg1, arg2, arg3})
	stub := fake.ConsoleInstanceDynamicStub
	fakeReturns := fake.consoleInstanceDynamicReturns
	fake.recordInvocation("ConsoleInstanceDynamic", []interface{}{arg1, arg2, arg3})
	fake.consoleInstanceDynamicMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) ConsoleInstanceDynamicCallCount() int {
	fake.consoleInstanceDynamicMutex.RLock()
	defer fake.consoleInstanceDynamicMutex.RUnlock()
	return len(fake.consoleInstanceDynamicArgsForCall)
}

func (fake *FakeContainerServer) ConsoleInstanceDynamicCalls(stub func(string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) (lxd.Operation, func(io.ReadWriteCloser) error, error)) {
	fake.consoleInstanceDynamicMutex.Lock()
	defer fake.consoleInstanceDynamicMutex.Unlock()
	fake.ConsoleInstanceDynamicStub = stub
}

func (fake *FakeContainerServer) ConsoleInstanceDynamicArgsForCall(i int) (string, api.InstanceConsolePost, *lxd.InstanceConsoleArgs) {
	fake.consoleInstanceDynamicMutex.RLock()
	defer fake.consoleInstanceDynamicMutex.RUnlock()
	argsForCall := fake.consoleInstanceDynamicArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) ConsoleInstanceDynamicReturns(result1 lxd.Operation, result2 func(io.ReadWriteCloser) error, result3 error) {
	fake.consoleInstanceDynamicMutex.Lock()
	defer fake.consoleInstanceDynamicMutex.Unlock()
	fake.ConsoleInstanceDynamicStub = nil
	fake.consoleInstanceDynamicReturns = struct {
		result1 lxd.Operation
		result2 func(io.ReadWriteCloser) error
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) ConsoleInstanceDynamicReturnsOnCall(i int, result1 lxd.Operation, result2 func(io.ReadWriteCloser) error, result3 error) {
	fake.consoleInstanceDynamicMutex.Lock()
	defer fake.consoleInstanceDynamicMutex.Unlock()
	fake.ConsoleInstanceDynamicStub = nil
	if fake.consoleInstanceDynamicReturnsOnCall == nil {
		fake.consoleInstanceDynamicReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 func(io.ReadWriteCloser) error
			result3 error
		})
	}
	fake.consoleInstanceDynamicReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 func(io.ReadWriteCloser) error
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) CopyContainer(arg1 lxd.InstanceServer, arg2 api.Container, arg3 *lxd.ContainerCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyContainerMutex.Lock()
	ret, specificReturn := fake.copyContainerReturnsOnCall[len(fake.copyContainerArgsForCall)]
	fake.copyContainerArgsForCall = append(fake.copyContainerArgsForCall, struct {
		arg1 lxd.InstanceServer
		arg2 api.Container
		arg3 *lxd.ContainerCopyArgs
	}{arg1, arg2, arg3})
	stub := fake.CopyContainerStub
	fakeReturns := fake.copyContainerReturns
	fake.recordInvocation("CopyContainer", []interface{}{arg1, arg2, arg3})
	fake.copyContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyContainerCallCount() int {
	fake.copyContainerMutex.RLock()
	defer fake.copyContainerMutex.RUnlock()
	return len(fake.copyContainerArgsForCall)
}

func (fake *FakeContainerServer) CopyContainerCalls(stub func(lxd.InstanceServer, api.Container, *lxd.ContainerCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyContainerMutex.Lock()
	defer fake.copyContainerMutex.Unlock()
	fake.CopyContainerStub = stub
}

func (fake *FakeContainerServer) CopyContainerArgsForCall(i int) (lxd.InstanceServer, api.Container, *lxd.ContainerCopyArgs) {
	fake.copyContainerMutex.RLock()
	defer fake.copyContainerMutex.RUnlock()
	argsForCall := fake.copyContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CopyContainerReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyContainerMutex.Lock()
	defer fake.copyContainerMutex.Unlock()
	fake.CopyContainerStub = nil
	fake.copyContainerReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyContainerReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyContainerMutex.Lock()
	defer fake.copyContainerMutex.Unlock()
	fake.CopyContainerStub = nil
	if fake.copyContainerReturnsOnCall == nil {
		fake.copyContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyContainerReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyContainerSnapshot(arg1 lxd.InstanceServer, arg2 string, arg3 api.ContainerSnapshot, arg4 *lxd.ContainerSnapshotCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.copyContainerSnapshotReturnsOnCall[len(fake.copyContainerSnapshotArgsForCall)]
	fake.copyContainerSnapshotArgsForCall = append(fake.copyContainerSnapshotArgsForCall, struct {
		arg1 lxd.InstanceServer
		arg2 string
		arg3 api.ContainerSnapshot
		arg4 *lxd.ContainerSnapshotCopyArgs
	}{arg1, arg2, arg3, arg4})
	stub := fake.CopyContainerSnapshotStub
	fakeReturns := fake.copyContainerSnapshotReturns
	fake.recordInvocation("CopyContainerSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.copyContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyContainerSnapshotCallCount() int {
	fake.copyContainerSnapshotMutex.RLock()
	defer fake.copyContainerSnapshotMutex.RUnlock()
	return len(fake.copyContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) CopyContainerSnapshotCalls(stub func(lxd.InstanceServer, string, api.ContainerSnapshot, *lxd.ContainerSnapshotCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyContainerSnapshotMutex.Lock()
	defer fake.copyContainerSnapshotMutex.Unlock()
	fake.CopyContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) CopyContainerSnapshotArgsForCall(i int) (lxd.InstanceServer, string, api.ContainerSnapshot, *lxd.ContainerSnapshotCopyArgs) {
	fake.copyContainerSnapshotMutex.RLock()
	defer fake.copyContainerSnapshotMutex.RUnlock()
	argsForCall := fake.copyContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) CopyContainerSnapshotReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyContainerSnapshotMutex.Lock()
	defer fake.copyContainerSnapshotMutex.Unlock()
	fake.CopyContainerSnapshotStub = nil
	fake.copyContainerSnapshotReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyContainerSnapshotReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyContainerSnapshotMutex.Lock()
	defer fake.copyContainerSnapshotMutex.Unlock()
	fake.CopyContainerSnapshotStub = nil
	if fake.copyContainerSnapshotReturnsOnCall == nil {
		fake.copyContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyImage(arg1 lxd.ImageServer, arg2 api.Image, arg3 *lxd.ImageCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyImageMutex.Lock()
	ret, specificReturn := fake.copyImageReturnsOnCall[len(fake.copyImageArgsForCall)]
	fake.copyImageArgsForCall = append(fake.copyImageArgsForCall, struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 *lxd.ImageCopyArgs
	}{arg1, arg2, arg3})
	stub := fake.CopyImageStub
	fakeReturns := fake.copyImageReturns
	fake.recordInvocation("CopyImage", []interface{}{arg1, arg2, arg3})
	fake.copyImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyImageCallCount() int {
	fake.copyImageMutex.RLock()
	defer fake.copyImageMutex.RUnlock()
	return len(fake.copyImageArgsForCall)
}

func (fake *FakeContainerServer) CopyImageCalls(stub func(lxd.ImageServer, api.Image, *lxd.ImageCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyImageMutex.Lock()
	defer fake.copyImageMutex.Unlock()
	fake.CopyImageStub = stub
}

func (fake *FakeContainerServer) CopyImageArgsForCall(i int) (lxd.ImageServer, api.Image, *lxd.ImageCopyArgs) {
	fake.copyImageMutex.RLock()
	defer fake.copyImageMutex.RUnlock()
	argsForCall := fake.copyImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CopyImageReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyImageMutex.Lock()
	defer fake.copyImageMutex.Unlock()
	fake.CopyImageStub = nil
	fake.copyImageReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyImageReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyImageMutex.Lock()
	defer fake.copyImageMutex.Unlock()
	fake.CopyImageStub = nil
	if fake.copyImageReturnsOnCall == nil {
		fake.copyImageReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyImageReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyInstance(arg1 lxd.InstanceServer, arg2 api.Instance, arg3 *lxd.InstanceCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyInstanceMutex.Lock()
	ret, specificReturn := fake.copyInstanceReturnsOnCall[len(fake.copyInstanceArgsForCall)]
	fake.copyInstanceArgsForCall = append(fake.copyInstanceArgsForCall, struct {
		arg1 lxd.InstanceServer
		arg2 api.Instance
		arg3 *lxd.InstanceCopyArgs
	}{arg1, arg2, arg3})
	stub := fake.CopyInstanceStub
	fakeReturns := fake.copyInstanceReturns
	fake.recordInvocation("CopyInstance", []interface{}{arg1, arg2, arg3})
	fake.copyInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyInstanceCallCount() int {
	fake.copyInstanceMutex.RLock()
	defer fake.copyInstanceMutex.RUnlock()
	return len(fake.copyInstanceArgsForCall)
}

func (fake *FakeContainerServer) CopyInstanceCalls(stub func(lxd.InstanceServer, api.Instance, *lxd.InstanceCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyInstanceMutex.Lock()
	defer fake.copyInstanceMutex.Unlock()
	fake.CopyInstanceStub = stub
}

func (fake *FakeContainerServer) CopyInstanceArgsForCall(i int) (lxd.InstanceServer, api.Instance, *lxd.InstanceCopyArgs) {
	fake.copyInstanceMutex.RLock()
	defer fake.copyInstanceMutex.RUnlock()
	argsForCall := fake.copyInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CopyInstanceReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyInstanceMutex.Lock()
	defer fake.copyInstanceMutex.Unlock()
	fake.CopyInstanceStub = nil
	fake.copyInstanceReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyInstanceReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyInstanceMutex.Lock()
	defer fake.copyInstanceMutex.Unlock()
	fake.CopyInstanceStub = nil
	if fake.copyInstanceReturnsOnCall == nil {
		fake.copyInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyInstanceReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyInstanceSnapshot(arg1 lxd.InstanceServer, arg2 string, arg3 api.InstanceSnapshot, arg4 *lxd.InstanceSnapshotCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.copyInstanceSnapshotReturnsOnCall[len(fake.copyInstanceSnapshotArgsForCall)]
	fake.copyInstanceSnapshotArgsForCall = append(fake.copyInstanceSnapshotArgsForCall, struct {
		arg1 lxd.InstanceServer
		arg2 string
		arg3 api.InstanceSnapshot
		arg4 *lxd.InstanceSnapshotCopyArgs
	}{arg1, arg2, arg3, arg4})
	stub := fake.CopyInstanceSnapshotStub
	fakeReturns := fake.copyInstanceSnapshotReturns
	fake.recordInvocation("CopyInstanceSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.copyInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyInstanceSnapshotCallCount() int {
	fake.copyInstanceSnapshotMutex.RLock()
	defer fake.copyInstanceSnapshotMutex.RUnlock()
	return len(fake.copyInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) CopyInstanceSnapshotCalls(stub func(lxd.InstanceServer, string, api.InstanceSnapshot, *lxd.InstanceSnapshotCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyInstanceSnapshotMutex.Lock()
	defer fake.copyInstanceSnapshotMutex.Unlock()
	fake.CopyInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) CopyInstanceSnapshotArgsForCall(i int) (lxd.InstanceServer, string, api.InstanceSnapshot, *lxd.InstanceSnapshotCopyArgs) {
	fake.copyInstanceSnapshotMutex.RLock()
	defer fake.copyInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.copyInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) CopyInstanceSnapshotReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyInstanceSnapshotMutex.Lock()
	defer fake.copyInstanceSnapshotMutex.Unlock()
	fake.CopyInstanceSnapshotStub = nil
	fake.copyInstanceSnapshotReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyInstanceSnapshotReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyInstanceSnapshotMutex.Lock()
	defer fake.copyInstanceSnapshotMutex.Unlock()
	fake.CopyInstanceSnapshotStub = nil
	if fake.copyInstanceSnapshotReturnsOnCall == nil {
		fake.copyInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyStoragePoolVolume(arg1 string, arg2 lxd.InstanceServer, arg3 string, arg4 api.StorageVolume, arg5 *lxd.StoragePoolVolumeCopyArgs) (lxd.RemoteOperation, error) {
	fake.copyStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.copyStoragePoolVolumeReturnsOnCall[len(fake.copyStoragePoolVolumeArgsForCall)]
	fake.copyStoragePoolVolumeArgsForCall = append(fake.copyStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 lxd.InstanceServer
		arg3 string
		arg4 api.StorageVolume
		arg5 *lxd.StoragePoolVolumeCopyArgs
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.CopyStoragePoolVolumeStub
	fakeReturns := fake.copyStoragePoolVolumeReturns
	fake.recordInvocation("CopyStoragePoolVolume", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.copyStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CopyStoragePoolVolumeCallCount() int {
	fake.copyStoragePoolVolumeMutex.RLock()
	defer fake.copyStoragePoolVolumeMutex.RUnlock()
	return len(fake.copyStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) CopyStoragePoolVolumeCalls(stub func(string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeCopyArgs) (lxd.RemoteOperation, error)) {
	fake.copyStoragePoolVolumeMutex.Lock()
	defer fake.copyStoragePoolVolumeMutex.Unlock()
	fake.CopyStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) CopyStoragePoolVolumeArgsForCall(i int) (string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeCopyArgs) {
	fake.copyStoragePoolVolumeMutex.RLock()
	defer fake.copyStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.copyStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeContainerServer) CopyStoragePoolVolumeReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.copyStoragePoolVolumeMutex.Lock()
	defer fake.copyStoragePoolVolumeMutex.Unlock()
	fake.CopyStoragePoolVolumeStub = nil
	fake.copyStoragePoolVolumeReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CopyStoragePoolVolumeReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.copyStoragePoolVolumeMutex.Lock()
	defer fake.copyStoragePoolVolumeMutex.Unlock()
	fake.CopyStoragePoolVolumeStub = nil
	if fake.copyStoragePoolVolumeReturnsOnCall == nil {
		fake.copyStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.copyStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateCertificate(arg1 api.CertificatesPost) error {
	fake.createCertificateMutex.Lock()
	ret, specificReturn := fake.createCertificateReturnsOnCall[len(fake.createCertificateArgsForCall)]
	fake.createCertificateArgsForCall = append(fake.createCertificateArgsForCall, struct {
		arg1 api.CertificatesPost
	}{arg1})
	stub := fake.CreateCertificateStub
	fakeReturns := fake.createCertificateReturns
	fake.recordInvocation("CreateCertificate", []interface{}{arg1})
	fake.createCertificateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateCertificateCallCount() int {
	fake.createCertificateMutex.RLock()
	defer fake.createCertificateMutex.RUnlock()
	return len(fake.createCertificateArgsForCall)
}

func (fake *FakeContainerServer) CreateCertificateCalls(stub func(api.CertificatesPost) error) {
	fake.createCertificateMutex.Lock()
	defer fake.createCertificateMutex.Unlock()
	fake.CreateCertificateStub = stub
}

func (fake *FakeContainerServer) CreateCertificateArgsForCall(i int) api.CertificatesPost {
	fake.createCertificateMutex.RLock()
	defer fake.createCertificateMutex.RUnlock()
	argsForCall := fake.createCertificateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateCertificateReturns(result1 error) {
	fake.createCertificateMutex.Lock()
	defer fake.createCertificateMutex.Unlock()
	fake.CreateCertificateStub = nil
	fake.createCertificateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateCertificateReturnsOnCall(i int, result1 error) {
	fake.createCertificateMutex.Lock()
	defer fake.createCertificateMutex.Unlock()
	fake.CreateCertificateStub = nil
	if fake.createCertificateReturnsOnCall == nil {
		fake.createCertificateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createCertificateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateCertificateToken(arg1 api.CertificatesPost) (lxd.Operation, error) {
	fake.createCertificateTokenMutex.Lock()
	ret, specificReturn := fake.createCertificateTokenReturnsOnCall[len(fake.createCertificateTokenArgsForCall)]
	fake.createCertificateTokenArgsForCall = append(fake.createCertificateTokenArgsForCall, struct {
		arg1 api.CertificatesPost
	}{arg1})
	stub := fake.CreateCertificateTokenStub
	fakeReturns := fake.createCertificateTokenReturns
	fake.recordInvocation("CreateCertificateToken", []interface{}{arg1})
	fake.createCertificateTokenMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateCertificateTokenCallCount() int {
	fake.createCertificateTokenMutex.RLock()
	defer fake.createCertificateTokenMutex.RUnlock()
	return len(fake.createCertificateTokenArgsForCall)
}

func (fake *FakeContainerServer) CreateCertificateTokenCalls(stub func(api.CertificatesPost) (lxd.Operation, error)) {
	fake.createCertificateTokenMutex.Lock()
	defer fake.createCertificateTokenMutex.Unlock()
	fake.CreateCertificateTokenStub = stub
}

func (fake *FakeContainerServer) CreateCertificateTokenArgsForCall(i int) api.CertificatesPost {
	fake.createCertificateTokenMutex.RLock()
	defer fake.createCertificateTokenMutex.RUnlock()
	argsForCall := fake.createCertificateTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateCertificateTokenReturns(result1 lxd.Operation, result2 error) {
	fake.createCertificateTokenMutex.Lock()
	defer fake.createCertificateTokenMutex.Unlock()
	fake.CreateCertificateTokenStub = nil
	fake.createCertificateTokenReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateCertificateTokenReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createCertificateTokenMutex.Lock()
	defer fake.createCertificateTokenMutex.Unlock()
	fake.CreateCertificateTokenStub = nil
	if fake.createCertificateTokenReturnsOnCall == nil {
		fake.createCertificateTokenReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createCertificateTokenReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateClusterGroup(arg1 api.ClusterGroupsPost) error {
	fake.createClusterGroupMutex.Lock()
	ret, specificReturn := fake.createClusterGroupReturnsOnCall[len(fake.createClusterGroupArgsForCall)]
	fake.createClusterGroupArgsForCall = append(fake.createClusterGroupArgsForCall, struct {
		arg1 api.ClusterGroupsPost
	}{arg1})
	stub := fake.CreateClusterGroupStub
	fakeReturns := fake.createClusterGroupReturns
	fake.recordInvocation("CreateClusterGroup", []interface{}{arg1})
	fake.createClusterGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateClusterGroupCallCount() int {
	fake.createClusterGroupMutex.RLock()
	defer fake.createClusterGroupMutex.RUnlock()
	return len(fake.createClusterGroupArgsForCall)
}

func (fake *FakeContainerServer) CreateClusterGroupCalls(stub func(api.ClusterGroupsPost) error) {
	fake.createClusterGroupMutex.Lock()
	defer fake.createClusterGroupMutex.Unlock()
	fake.CreateClusterGroupStub = stub
}

func (fake *FakeContainerServer) CreateClusterGroupArgsForCall(i int) api.ClusterGroupsPost {
	fake.createClusterGroupMutex.RLock()
	defer fake.createClusterGroupMutex.RUnlock()
	argsForCall := fake.createClusterGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateClusterGroupReturns(result1 error) {
	fake.createClusterGroupMutex.Lock()
	defer fake.createClusterGroupMutex.Unlock()
	fake.CreateClusterGroupStub = nil
	fake.createClusterGroupReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateClusterGroupReturnsOnCall(i int, result1 error) {
	fake.createClusterGroupMutex.Lock()
	defer fake.createClusterGroupMutex.Unlock()
	fake.CreateClusterGroupStub = nil
	if fake.createClusterGroupReturnsOnCall == nil {
		fake.createClusterGroupReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createClusterGroupReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateClusterMember(arg1 api.ClusterMembersPost) (lxd.Operation, error) {
	fake.createClusterMemberMutex.Lock()
	ret, specificReturn := fake.createClusterMemberReturnsOnCall[len(fake.createClusterMemberArgsForCall)]
	fake.createClusterMemberArgsForCall = append(fake.createClusterMemberArgsForCall, struct {
		arg1 api.ClusterMembersPost
	}{arg1})
	stub := fake.CreateClusterMemberStub
	fakeReturns := fake.createClusterMemberReturns
	fake.recordInvocation("CreateClusterMember", []interface{}{arg1})
	fake.createClusterMemberMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateClusterMemberCallCount() int {
	fake.createClusterMemberMutex.RLock()
	defer fake.createClusterMemberMutex.RUnlock()
	return len(fake.createClusterMemberArgsForCall)
}

func (fake *FakeContainerServer) CreateClusterMemberCalls(stub func(api.ClusterMembersPost) (lxd.Operation, error)) {
	fake.createClusterMemberMutex.Lock()
	defer fake.createClusterMemberMutex.Unlock()
	fake.CreateClusterMemberStub = stub
}

func (fake *FakeContainerServer) CreateClusterMemberArgsForCall(i int) api.ClusterMembersPost {
	fake.createClusterMemberMutex.RLock()
	defer fake.createClusterMemberMutex.RUnlock()
	argsForCall := fake.createClusterMemberArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateClusterMemberReturns(result1 lxd.Operation, result2 error) {
	fake.createClusterMemberMutex.Lock()
	defer fake.createClusterMemberMutex.Unlock()
	fake.CreateClusterMemberStub = nil
	fake.createClusterMemberReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateClusterMemberReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createClusterMemberMutex.Lock()
	defer fake.createClusterMemberMutex.Unlock()
	fake.CreateClusterMemberStub = nil
	if fake.createClusterMemberReturnsOnCall == nil {
		fake.createClusterMemberReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createClusterMemberReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainer(arg1 api.ContainersPost) (lxd.Operation, error) {
	fake.createContainerMutex.Lock()
	ret, specificReturn := fake.createContainerReturnsOnCall[len(fake.createContainerArgsForCall)]
	fake.createContainerArgsForCall = append(fake.createContainerArgsForCall, struct {
		arg1 api.ContainersPost
	}{arg1})
	stub := fake.CreateContainerStub
	fakeReturns := fake.createContainerReturns
	fake.recordInvocation("CreateContainer", []interface{}{arg1})
	fake.createContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateContainerCallCount() int {
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	return len(fake.createContainerArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerCalls(stub func(api.ContainersPost) (lxd.Operation, error)) {
	fake.createContainerMutex.Lock()
	defer fake.createContainerMutex.Unlock()
	fake.CreateContainerStub = stub
}

func (fake *FakeContainerServer) CreateContainerArgsForCall(i int) api.ContainersPost {
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	argsForCall := fake.createContainerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateContainerReturns(result1 lxd.Operation, result2 error) {
	fake.createContainerMutex.Lock()
	defer fake.createContainerMutex.Unlock()
	fake.CreateContainerStub = nil
	fake.createContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createContainerMutex.Lock()
	defer fake.createContainerMutex.Unlock()
	fake.CreateContainerStub = nil
	if fake.createContainerReturnsOnCall == nil {
		fake.createContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerBackup(arg1 string, arg2 api.ContainerBackupsPost) (lxd.Operation, error) {
	fake.createContainerBackupMutex.Lock()
	ret, specificReturn := fake.createContainerBackupReturnsOnCall[len(fake.createContainerBackupArgsForCall)]
	fake.createContainerBackupArgsForCall = append(fake.createContainerBackupArgsForCall, struct {
		arg1 string
		arg2 api.ContainerBackupsPost
	}{arg1, arg2})
	stub := fake.CreateContainerBackupStub
	fakeReturns := fake.createContainerBackupReturns
	fake.recordInvocation("CreateContainerBackup", []interface{}{arg1, arg2})
	fake.createContainerBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateContainerBackupCallCount() int {
	fake.createContainerBackupMutex.RLock()
	defer fake.createContainerBackupMutex.RUnlock()
	return len(fake.createContainerBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerBackupCalls(stub func(string, api.ContainerBackupsPost) (lxd.Operation, error)) {
	fake.createContainerBackupMutex.Lock()
	defer fake.createContainerBackupMutex.Unlock()
	fake.CreateContainerBackupStub = stub
}

func (fake *FakeContainerServer) CreateContainerBackupArgsForCall(i int) (string, api.ContainerBackupsPost) {
	fake.createContainerBackupMutex.RLock()
	defer fake.createContainerBackupMutex.RUnlock()
	argsForCall := fake.createContainerBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateContainerBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createContainerBackupMutex.Lock()
	defer fake.createContainerBackupMutex.Unlock()
	fake.CreateContainerBackupStub = nil
	fake.createContainerBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createContainerBackupMutex.Lock()
	defer fake.createContainerBackupMutex.Unlock()
	fake.CreateContainerBackupStub = nil
	if fake.createContainerBackupReturnsOnCall == nil {
		fake.createContainerBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createContainerBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerFile(arg1 string, arg2 string, arg3 lxd.ContainerFileArgs) error {
	fake.createContainerFileMutex.Lock()
	ret, specificReturn := fake.createContainerFileReturnsOnCall[len(fake.createContainerFileArgsForCall)]
	fake.createContainerFileArgsForCall = append(fake.createContainerFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 lxd.ContainerFileArgs
	}{arg1, arg2, arg3})
	stub := fake.CreateContainerFileStub
	fakeReturns := fake.createContainerFileReturns
	fake.recordInvocation("CreateContainerFile", []interface{}{arg1, arg2, arg3})
	fake.createContainerFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateContainerFileCallCount() int {
	fake.createContainerFileMutex.RLock()
	defer fake.createContainerFileMutex.RUnlock()
	return len(fake.createContainerFileArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerFileCalls(stub func(string, string, lxd.ContainerFileArgs) error) {
	fake.createContainerFileMutex.Lock()
	defer fake.createContainerFileMutex.Unlock()
	fake.CreateContainerFileStub = stub
}

func (fake *FakeContainerServer) CreateContainerFileArgsForCall(i int) (string, string, lxd.ContainerFileArgs) {
	fake.createContainerFileMutex.RLock()
	defer fake.createContainerFileMutex.RUnlock()
	argsForCall := fake.createContainerFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateContainerFileReturns(result1 error) {
	fake.createContainerFileMutex.Lock()
	defer fake.createContainerFileMutex.Unlock()
	fake.CreateContainerFileStub = nil
	fake.createContainerFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateContainerFileReturnsOnCall(i int, result1 error) {
	fake.createContainerFileMutex.Lock()
	defer fake.createContainerFileMutex.Unlock()
	fake.CreateContainerFileStub = nil
	if fake.createContainerFileReturnsOnCall == nil {
		fake.createContainerFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createContainerFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateContainerFromBackup(arg1 lxd.ContainerBackupArgs) (lxd.Operation, error) {
	fake.createContainerFromBackupMutex.Lock()
	ret, specificReturn := fake.createContainerFromBackupReturnsOnCall[len(fake.createContainerFromBackupArgsForCall)]
	fake.createContainerFromBackupArgsForCall = append(fake.createContainerFromBackupArgsForCall, struct {
		arg1 lxd.ContainerBackupArgs
	}{arg1})
	stub := fake.CreateContainerFromBackupStub
	fakeReturns := fake.createContainerFromBackupReturns
	fake.recordInvocation("CreateContainerFromBackup", []interface{}{arg1})
	fake.createContainerFromBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateContainerFromBackupCallCount() int {
	fake.createContainerFromBackupMutex.RLock()
	defer fake.createContainerFromBackupMutex.RUnlock()
	return len(fake.createContainerFromBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerFromBackupCalls(stub func(lxd.ContainerBackupArgs) (lxd.Operation, error)) {
	fake.createContainerFromBackupMutex.Lock()
	defer fake.createContainerFromBackupMutex.Unlock()
	fake.CreateContainerFromBackupStub = stub
}

func (fake *FakeContainerServer) CreateContainerFromBackupArgsForCall(i int) lxd.ContainerBackupArgs {
	fake.createContainerFromBackupMutex.RLock()
	defer fake.createContainerFromBackupMutex.RUnlock()
	argsForCall := fake.createContainerFromBackupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateContainerFromBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createContainerFromBackupMutex.Lock()
	defer fake.createContainerFromBackupMutex.Unlock()
	fake.CreateContainerFromBackupStub = nil
	fake.createContainerFromBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerFromBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createContainerFromBackupMutex.Lock()
	defer fake.createContainerFromBackupMutex.Unlock()
	fake.CreateContainerFromBackupStub = nil
	if fake.createContainerFromBackupReturnsOnCall == nil {
		fake.createContainerFromBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createContainerFromBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerFromImage(arg1 lxd.ImageServer, arg2 api.Image, arg3 api.ContainersPost) (lxd.RemoteOperation, error) {
	fake.createContainerFromImageMutex.Lock()
	ret, specificReturn := fake.createContainerFromImageReturnsOnCall[len(fake.createContainerFromImageArgsForCall)]
	fake.createContainerFromImageArgsForCall = append(fake.createContainerFromImageArgsForCall, struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 api.ContainersPost
	}{arg1, arg2, arg3})
	stub := fake.CreateContainerFromImageStub
	fakeReturns := fake.createContainerFromImageReturns
	fake.recordInvocation("CreateContainerFromImage", []interface{}{arg1, arg2, arg3})
	fake.createContainerFromImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateContainerFromImageCallCount() int {
	fake.createContainerFromImageMutex.RLock()
	defer fake.createContainerFromImageMutex.RUnlock()
	return len(fake.createContainerFromImageArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerFromImageCalls(stub func(lxd.ImageServer, api.Image, api.ContainersPost) (lxd.RemoteOperation, error)) {
	fake.createContainerFromImageMutex.Lock()
	defer fake.createContainerFromImageMutex.Unlock()
	fake.CreateContainerFromImageStub = stub
}

func (fake *FakeContainerServer) CreateContainerFromImageArgsForCall(i int) (lxd.ImageServer, api.Image, api.ContainersPost) {
	fake.createContainerFromImageMutex.RLock()
	defer fake.createContainerFromImageMutex.RUnlock()
	argsForCall := fake.createContainerFromImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateContainerFromImageReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.createContainerFromImageMutex.Lock()
	defer fake.createContainerFromImageMutex.Unlock()
	fake.CreateContainerFromImageStub = nil
	fake.createContainerFromImageReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerFromImageReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.createContainerFromImageMutex.Lock()
	defer fake.createContainerFromImageMutex.Unlock()
	fake.CreateContainerFromImageStub = nil
	if fake.createContainerFromImageReturnsOnCall == nil {
		fake.createContainerFromImageReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.createContainerFromImageReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerSnapshot(arg1 string, arg2 api.ContainerSnapshotsPost) (lxd.Operation, error) {
	fake.createContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.createContainerSnapshotReturnsOnCall[len(fake.createContainerSnapshotArgsForCall)]
	fake.createContainerSnapshotArgsForCall = append(fake.createContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 api.ContainerSnapshotsPost
	}{arg1, arg2})
	stub := fake.CreateContainerSnapshotStub
	fakeReturns := fake.createContainerSnapshotReturns
	fake.recordInvocation("CreateContainerSnapshot", []interface{}{arg1, arg2})
	fake.createContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateContainerSnapshotCallCount() int {
	fake.createContainerSnapshotMutex.RLock()
	defer fake.createContainerSnapshotMutex.RUnlock()
	return len(fake.createContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerSnapshotCalls(stub func(string, api.ContainerSnapshotsPost) (lxd.Operation, error)) {
	fake.createContainerSnapshotMutex.Lock()
	defer fake.createContainerSnapshotMutex.Unlock()
	fake.CreateContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) CreateContainerSnapshotArgsForCall(i int) (string, api.ContainerSnapshotsPost) {
	fake.createContainerSnapshotMutex.RLock()
	defer fake.createContainerSnapshotMutex.RUnlock()
	argsForCall := fake.createContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateContainerSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.createContainerSnapshotMutex.Lock()
	defer fake.createContainerSnapshotMutex.Unlock()
	fake.CreateContainerSnapshotStub = nil
	fake.createContainerSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createContainerSnapshotMutex.Lock()
	defer fake.createContainerSnapshotMutex.Unlock()
	fake.CreateContainerSnapshotStub = nil
	if fake.createContainerSnapshotReturnsOnCall == nil {
		fake.createContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateContainerTemplateFile(arg1 string, arg2 string, arg3 io.ReadSeeker) error {
	fake.createContainerTemplateFileMutex.Lock()
	ret, specificReturn := fake.createContainerTemplateFileReturnsOnCall[len(fake.createContainerTemplateFileArgsForCall)]
	fake.createContainerTemplateFileArgsForCall = append(fake.createContainerTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}{arg1, arg2, arg3})
	stub := fake.CreateContainerTemplateFileStub
	fakeReturns := fake.createContainerTemplateFileReturns
	fake.recordInvocation("CreateContainerTemplateFile", []interface{}{arg1, arg2, arg3})
	fake.createContainerTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateContainerTemplateFileCallCount() int {
	fake.createContainerTemplateFileMutex.RLock()
	defer fake.createContainerTemplateFileMutex.RUnlock()
	return len(fake.createContainerTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) CreateContainerTemplateFileCalls(stub func(string, string, io.ReadSeeker) error) {
	fake.createContainerTemplateFileMutex.Lock()
	defer fake.createContainerTemplateFileMutex.Unlock()
	fake.CreateContainerTemplateFileStub = stub
}

func (fake *FakeContainerServer) CreateContainerTemplateFileArgsForCall(i int) (string, string, io.ReadSeeker) {
	fake.createContainerTemplateFileMutex.RLock()
	defer fake.createContainerTemplateFileMutex.RUnlock()
	argsForCall := fake.createContainerTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateContainerTemplateFileReturns(result1 error) {
	fake.createContainerTemplateFileMutex.Lock()
	defer fake.createContainerTemplateFileMutex.Unlock()
	fake.CreateContainerTemplateFileStub = nil
	fake.createContainerTemplateFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateContainerTemplateFileReturnsOnCall(i int, result1 error) {
	fake.createContainerTemplateFileMutex.Lock()
	defer fake.createContainerTemplateFileMutex.Unlock()
	fake.CreateContainerTemplateFileStub = nil
	if fake.createContainerTemplateFileReturnsOnCall == nil {
		fake.createContainerTemplateFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createContainerTemplateFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateImage(arg1 api.ImagesPost, arg2 *lxd.ImageCreateArgs) (lxd.Operation, error) {
	fake.createImageMutex.Lock()
	ret, specificReturn := fake.createImageReturnsOnCall[len(fake.createImageArgsForCall)]
	fake.createImageArgsForCall = append(fake.createImageArgsForCall, struct {
		arg1 api.ImagesPost
		arg2 *lxd.ImageCreateArgs
	}{arg1, arg2})
	stub := fake.CreateImageStub
	fakeReturns := fake.createImageReturns
	fake.recordInvocation("CreateImage", []interface{}{arg1, arg2})
	fake.createImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateImageCallCount() int {
	fake.createImageMutex.RLock()
	defer fake.createImageMutex.RUnlock()
	return len(fake.createImageArgsForCall)
}

func (fake *FakeContainerServer) CreateImageCalls(stub func(api.ImagesPost, *lxd.ImageCreateArgs) (lxd.Operation, error)) {
	fake.createImageMutex.Lock()
	defer fake.createImageMutex.Unlock()
	fake.CreateImageStub = stub
}

func (fake *FakeContainerServer) CreateImageArgsForCall(i int) (api.ImagesPost, *lxd.ImageCreateArgs) {
	fake.createImageMutex.RLock()
	defer fake.createImageMutex.RUnlock()
	argsForCall := fake.createImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateImageReturns(result1 lxd.Operation, result2 error) {
	fake.createImageMutex.Lock()
	defer fake.createImageMutex.Unlock()
	fake.CreateImageStub = nil
	fake.createImageReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateImageReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createImageMutex.Lock()
	defer fake.createImageMutex.Unlock()
	fake.CreateImageStub = nil
	if fake.createImageReturnsOnCall == nil {
		fake.createImageReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createImageReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateImageAlias(arg1 api.ImageAliasesPost) error {
	fake.createImageAliasMutex.Lock()
	ret, specificReturn := fake.createImageAliasReturnsOnCall[len(fake.createImageAliasArgsForCall)]
	fake.createImageAliasArgsForCall = append(fake.createImageAliasArgsForCall, struct {
		arg1 api.ImageAliasesPost
	}{arg1})
	stub := fake.CreateImageAliasStub
	fakeReturns := fake.createImageAliasReturns
	fake.recordInvocation("CreateImageAlias", []interface{}{arg1})
	fake.createImageAliasMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateImageAliasCallCount() int {
	fake.createImageAliasMutex.RLock()
	defer fake.createImageAliasMutex.RUnlock()
	return len(fake.createImageAliasArgsForCall)
}

func (fake *FakeContainerServer) CreateImageAliasCalls(stub func(api.ImageAliasesPost) error) {
	fake.createImageAliasMutex.Lock()
	defer fake.createImageAliasMutex.Unlock()
	fake.CreateImageAliasStub = stub
}

func (fake *FakeContainerServer) CreateImageAliasArgsForCall(i int) api.ImageAliasesPost {
	fake.createImageAliasMutex.RLock()
	defer fake.createImageAliasMutex.RUnlock()
	argsForCall := fake.createImageAliasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateImageAliasReturns(result1 error) {
	fake.createImageAliasMutex.Lock()
	defer fake.createImageAliasMutex.Unlock()
	fake.CreateImageAliasStub = nil
	fake.createImageAliasReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateImageAliasReturnsOnCall(i int, result1 error) {
	fake.createImageAliasMutex.Lock()
	defer fake.createImageAliasMutex.Unlock()
	fake.CreateImageAliasStub = nil
	if fake.createImageAliasReturnsOnCall == nil {
		fake.createImageAliasReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createImageAliasReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateImageSecret(arg1 string) (lxd.Operation, error) {
	fake.createImageSecretMutex.Lock()
	ret, specificReturn := fake.createImageSecretReturnsOnCall[len(fake.createImageSecretArgsForCall)]
	fake.createImageSecretArgsForCall = append(fake.createImageSecretArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CreateImageSecretStub
	fakeReturns := fake.createImageSecretReturns
	fake.recordInvocation("CreateImageSecret", []interface{}{arg1})
	fake.createImageSecretMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateImageSecretCallCount() int {
	fake.createImageSecretMutex.RLock()
	defer fake.createImageSecretMutex.RUnlock()
	return len(fake.createImageSecretArgsForCall)
}

func (fake *FakeContainerServer) CreateImageSecretCalls(stub func(string) (lxd.Operation, error)) {
	fake.createImageSecretMutex.Lock()
	defer fake.createImageSecretMutex.Unlock()
	fake.CreateImageSecretStub = stub
}

func (fake *FakeContainerServer) CreateImageSecretArgsForCall(i int) string {
	fake.createImageSecretMutex.RLock()
	defer fake.createImageSecretMutex.RUnlock()
	argsForCall := fake.createImageSecretArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateImageSecretReturns(result1 lxd.Operation, result2 error) {
	fake.createImageSecretMutex.Lock()
	defer fake.createImageSecretMutex.Unlock()
	fake.CreateImageSecretStub = nil
	fake.createImageSecretReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateImageSecretReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createImageSecretMutex.Lock()
	defer fake.createImageSecretMutex.Unlock()
	fake.CreateImageSecretStub = nil
	if fake.createImageSecretReturnsOnCall == nil {
		fake.createImageSecretReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createImageSecretReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstance(arg1 api.InstancesPost) (lxd.Operation, error) {
	fake.createInstanceMutex.Lock()
	ret, specificReturn := fake.createInstanceReturnsOnCall[len(fake.createInstanceArgsForCall)]
	fake.createInstanceArgsForCall = append(fake.createInstanceArgsForCall, struct {
		arg1 api.InstancesPost
	}{arg1})
	stub := fake.CreateInstanceStub
	fakeReturns := fake.createInstanceReturns
	fake.recordInvocation("CreateInstance", []interface{}{arg1})
	fake.createInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateInstanceCallCount() int {
	fake.createInstanceMutex.RLock()
	defer fake.createInstanceMutex.RUnlock()
	return len(fake.createInstanceArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceCalls(stub func(api.InstancesPost) (lxd.Operation, error)) {
	fake.createInstanceMutex.Lock()
	defer fake.createInstanceMutex.Unlock()
	fake.CreateInstanceStub = stub
}

func (fake *FakeContainerServer) CreateInstanceArgsForCall(i int) api.InstancesPost {
	fake.createInstanceMutex.RLock()
	defer fake.createInstanceMutex.RUnlock()
	argsForCall := fake.createInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.createInstanceMutex.Lock()
	defer fake.createInstanceMutex.Unlock()
	fake.CreateInstanceStub = nil
	fake.createInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createInstanceMutex.Lock()
	defer fake.createInstanceMutex.Unlock()
	fake.CreateInstanceStub = nil
	if fake.createInstanceReturnsOnCall == nil {
		fake.createInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceBackup(arg1 string, arg2 api.InstanceBackupsPost) (lxd.Operation, error) {
	fake.createInstanceBackupMutex.Lock()
	ret, specificReturn := fake.createInstanceBackupReturnsOnCall[len(fake.createInstanceBackupArgsForCall)]
	fake.createInstanceBackupArgsForCall = append(fake.createInstanceBackupArgsForCall, struct {
		arg1 string
		arg2 api.InstanceBackupsPost
	}{arg1, arg2})
	stub := fake.CreateInstanceBackupStub
	fakeReturns := fake.createInstanceBackupReturns
	fake.recordInvocation("CreateInstanceBackup", []interface{}{arg1, arg2})
	fake.createInstanceBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateInstanceBackupCallCount() int {
	fake.createInstanceBackupMutex.RLock()
	defer fake.createInstanceBackupMutex.RUnlock()
	return len(fake.createInstanceBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceBackupCalls(stub func(string, api.InstanceBackupsPost) (lxd.Operation, error)) {
	fake.createInstanceBackupMutex.Lock()
	defer fake.createInstanceBackupMutex.Unlock()
	fake.CreateInstanceBackupStub = stub
}

func (fake *FakeContainerServer) CreateInstanceBackupArgsForCall(i int) (string, api.InstanceBackupsPost) {
	fake.createInstanceBackupMutex.RLock()
	defer fake.createInstanceBackupMutex.RUnlock()
	argsForCall := fake.createInstanceBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateInstanceBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createInstanceBackupMutex.Lock()
	defer fake.createInstanceBackupMutex.Unlock()
	fake.CreateInstanceBackupStub = nil
	fake.createInstanceBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createInstanceBackupMutex.Lock()
	defer fake.createInstanceBackupMutex.Unlock()
	fake.CreateInstanceBackupStub = nil
	if fake.createInstanceBackupReturnsOnCall == nil {
		fake.createInstanceBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createInstanceBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceFile(arg1 string, arg2 string, arg3 lxd.InstanceFileArgs) error {
	fake.createInstanceFileMutex.Lock()
	ret, specificReturn := fake.createInstanceFileReturnsOnCall[len(fake.createInstanceFileArgsForCall)]
	fake.createInstanceFileArgsForCall = append(fake.createInstanceFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 lxd.InstanceFileArgs
	}{arg1, arg2, arg3})
	stub := fake.CreateInstanceFileStub
	fakeReturns := fake.createInstanceFileReturns
	fake.recordInvocation("CreateInstanceFile", []interface{}{arg1, arg2, arg3})
	fake.createInstanceFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateInstanceFileCallCount() int {
	fake.createInstanceFileMutex.RLock()
	defer fake.createInstanceFileMutex.RUnlock()
	return len(fake.createInstanceFileArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceFileCalls(stub func(string, string, lxd.InstanceFileArgs) error) {
	fake.createInstanceFileMutex.Lock()
	defer fake.createInstanceFileMutex.Unlock()
	fake.CreateInstanceFileStub = stub
}

func (fake *FakeContainerServer) CreateInstanceFileArgsForCall(i int) (string, string, lxd.InstanceFileArgs) {
	fake.createInstanceFileMutex.RLock()
	defer fake.createInstanceFileMutex.RUnlock()
	argsForCall := fake.createInstanceFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateInstanceFileReturns(result1 error) {
	fake.createInstanceFileMutex.Lock()
	defer fake.createInstanceFileMutex.Unlock()
	fake.CreateInstanceFileStub = nil
	fake.createInstanceFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateInstanceFileReturnsOnCall(i int, result1 error) {
	fake.createInstanceFileMutex.Lock()
	defer fake.createInstanceFileMutex.Unlock()
	fake.CreateInstanceFileStub = nil
	if fake.createInstanceFileReturnsOnCall == nil {
		fake.createInstanceFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createInstanceFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateInstanceFromBackup(arg1 lxd.InstanceBackupArgs) (lxd.Operation, error) {
	fake.createInstanceFromBackupMutex.Lock()
	ret, specificReturn := fake.createInstanceFromBackupReturnsOnCall[len(fake.createInstanceFromBackupArgsForCall)]
	fake.createInstanceFromBackupArgsForCall = append(fake.createInstanceFromBackupArgsForCall, struct {
		arg1 lxd.InstanceBackupArgs
	}{arg1})
	stub := fake.CreateInstanceFromBackupStub
	fakeReturns := fake.createInstanceFromBackupReturns
	fake.recordInvocation("CreateInstanceFromBackup", []interface{}{arg1})
	fake.createInstanceFromBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateInstanceFromBackupCallCount() int {
	fake.createInstanceFromBackupMutex.RLock()
	defer fake.createInstanceFromBackupMutex.RUnlock()
	return len(fake.createInstanceFromBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceFromBackupCalls(stub func(lxd.InstanceBackupArgs) (lxd.Operation, error)) {
	fake.createInstanceFromBackupMutex.Lock()
	defer fake.createInstanceFromBackupMutex.Unlock()
	fake.CreateInstanceFromBackupStub = stub
}

func (fake *FakeContainerServer) CreateInstanceFromBackupArgsForCall(i int) lxd.InstanceBackupArgs {
	fake.createInstanceFromBackupMutex.RLock()
	defer fake.createInstanceFromBackupMutex.RUnlock()
	argsForCall := fake.createInstanceFromBackupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateInstanceFromBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createInstanceFromBackupMutex.Lock()
	defer fake.createInstanceFromBackupMutex.Unlock()
	fake.CreateInstanceFromBackupStub = nil
	fake.createInstanceFromBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceFromBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createInstanceFromBackupMutex.Lock()
	defer fake.createInstanceFromBackupMutex.Unlock()
	fake.CreateInstanceFromBackupStub = nil
	if fake.createInstanceFromBackupReturnsOnCall == nil {
		fake.createInstanceFromBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createInstanceFromBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceFromImage(arg1 lxd.ImageServer, arg2 api.Image, arg3 api.InstancesPost) (lxd.RemoteOperation, error) {
	fake.createInstanceFromImageMutex.Lock()
	ret, specificReturn := fake.createInstanceFromImageReturnsOnCall[len(fake.createInstanceFromImageArgsForCall)]
	fake.createInstanceFromImageArgsForCall = append(fake.createInstanceFromImageArgsForCall, struct {
		arg1 lxd.ImageServer
		arg2 api.Image
		arg3 api.InstancesPost
	}{arg1, arg2, arg3})
	stub := fake.CreateInstanceFromImageStub
	fakeReturns := fake.createInstanceFromImageReturns
	fake.recordInvocation("CreateInstanceFromImage", []interface{}{arg1, arg2, arg3})
	fake.createInstanceFromImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateInstanceFromImageCallCount() int {
	fake.createInstanceFromImageMutex.RLock()
	defer fake.createInstanceFromImageMutex.RUnlock()
	return len(fake.createInstanceFromImageArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceFromImageCalls(stub func(lxd.ImageServer, api.Image, api.InstancesPost) (lxd.RemoteOperation, error)) {
	fake.createInstanceFromImageMutex.Lock()
	defer fake.createInstanceFromImageMutex.Unlock()
	fake.CreateInstanceFromImageStub = stub
}

func (fake *FakeContainerServer) CreateInstanceFromImageArgsForCall(i int) (lxd.ImageServer, api.Image, api.InstancesPost) {
	fake.createInstanceFromImageMutex.RLock()
	defer fake.createInstanceFromImageMutex.RUnlock()
	argsForCall := fake.createInstanceFromImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateInstanceFromImageReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.createInstanceFromImageMutex.Lock()
	defer fake.createInstanceFromImageMutex.Unlock()
	fake.CreateInstanceFromImageStub = nil
	fake.createInstanceFromImageReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceFromImageReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.createInstanceFromImageMutex.Lock()
	defer fake.createInstanceFromImageMutex.Unlock()
	fake.CreateInstanceFromImageStub = nil
	if fake.createInstanceFromImageReturnsOnCall == nil {
		fake.createInstanceFromImageReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.createInstanceFromImageReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceSnapshot(arg1 string, arg2 api.InstanceSnapshotsPost) (lxd.Operation, error) {
	fake.createInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.createInstanceSnapshotReturnsOnCall[len(fake.createInstanceSnapshotArgsForCall)]
	fake.createInstanceSnapshotArgsForCall = append(fake.createInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 api.InstanceSnapshotsPost
	}{arg1, arg2})
	stub := fake.CreateInstanceSnapshotStub
	fakeReturns := fake.createInstanceSnapshotReturns
	fake.recordInvocation("CreateInstanceSnapshot", []interface{}{arg1, arg2})
	fake.createInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateInstanceSnapshotCallCount() int {
	fake.createInstanceSnapshotMutex.RLock()
	defer fake.createInstanceSnapshotMutex.RUnlock()
	return len(fake.createInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceSnapshotCalls(stub func(string, api.InstanceSnapshotsPost) (lxd.Operation, error)) {
	fake.createInstanceSnapshotMutex.Lock()
	defer fake.createInstanceSnapshotMutex.Unlock()
	fake.CreateInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) CreateInstanceSnapshotArgsForCall(i int) (string, api.InstanceSnapshotsPost) {
	fake.createInstanceSnapshotMutex.RLock()
	defer fake.createInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.createInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateInstanceSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.createInstanceSnapshotMutex.Lock()
	defer fake.createInstanceSnapshotMutex.Unlock()
	fake.CreateInstanceSnapshotStub = nil
	fake.createInstanceSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createInstanceSnapshotMutex.Lock()
	defer fake.createInstanceSnapshotMutex.Unlock()
	fake.CreateInstanceSnapshotStub = nil
	if fake.createInstanceSnapshotReturnsOnCall == nil {
		fake.createInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateInstanceTemplateFile(arg1 string, arg2 string, arg3 io.ReadSeeker) error {
	fake.createInstanceTemplateFileMutex.Lock()
	ret, specificReturn := fake.createInstanceTemplateFileReturnsOnCall[len(fake.createInstanceTemplateFileArgsForCall)]
	fake.createInstanceTemplateFileArgsForCall = append(fake.createInstanceTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}{arg1, arg2, arg3})
	stub := fake.CreateInstanceTemplateFileStub
	fakeReturns := fake.createInstanceTemplateFileReturns
	fake.recordInvocation("CreateInstanceTemplateFile", []interface{}{arg1, arg2, arg3})
	fake.createInstanceTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateInstanceTemplateFileCallCount() int {
	fake.createInstanceTemplateFileMutex.RLock()
	defer fake.createInstanceTemplateFileMutex.RUnlock()
	return len(fake.createInstanceTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) CreateInstanceTemplateFileCalls(stub func(string, string, io.ReadSeeker) error) {
	fake.createInstanceTemplateFileMutex.Lock()
	defer fake.createInstanceTemplateFileMutex.Unlock()
	fake.CreateInstanceTemplateFileStub = stub
}

func (fake *FakeContainerServer) CreateInstanceTemplateFileArgsForCall(i int) (string, string, io.ReadSeeker) {
	fake.createInstanceTemplateFileMutex.RLock()
	defer fake.createInstanceTemplateFileMutex.RUnlock()
	argsForCall := fake.createInstanceTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateInstanceTemplateFileReturns(result1 error) {
	fake.createInstanceTemplateFileMutex.Lock()
	defer fake.createInstanceTemplateFileMutex.Unlock()
	fake.CreateInstanceTemplateFileStub = nil
	fake.createInstanceTemplateFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateInstanceTemplateFileReturnsOnCall(i int, result1 error) {
	fake.createInstanceTemplateFileMutex.Lock()
	defer fake.createInstanceTemplateFileMutex.Unlock()
	fake.CreateInstanceTemplateFileStub = nil
	if fake.createInstanceTemplateFileReturnsOnCall == nil {
		fake.createInstanceTemplateFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createInstanceTemplateFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetwork(arg1 api.NetworksPost) error {
	fake.createNetworkMutex.Lock()
	ret, specificReturn := fake.createNetworkReturnsOnCall[len(fake.createNetworkArgsForCall)]
	fake.createNetworkArgsForCall = append(fake.createNetworkArgsForCall, struct {
		arg1 api.NetworksPost
	}{arg1})
	stub := fake.CreateNetworkStub
	fakeReturns := fake.createNetworkReturns
	fake.recordInvocation("CreateNetwork", []interface{}{arg1})
	fake.createNetworkMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkCallCount() int {
	fake.createNetworkMutex.RLock()
	defer fake.createNetworkMutex.RUnlock()
	return len(fake.createNetworkArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkCalls(stub func(api.NetworksPost) error) {
	fake.createNetworkMutex.Lock()
	defer fake.createNetworkMutex.Unlock()
	fake.CreateNetworkStub = stub
}

func (fake *FakeContainerServer) CreateNetworkArgsForCall(i int) api.NetworksPost {
	fake.createNetworkMutex.RLock()
	defer fake.createNetworkMutex.RUnlock()
	argsForCall := fake.createNetworkArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateNetworkReturns(result1 error) {
	fake.createNetworkMutex.Lock()
	defer fake.createNetworkMutex.Unlock()
	fake.CreateNetworkStub = nil
	fake.createNetworkReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkReturnsOnCall(i int, result1 error) {
	fake.createNetworkMutex.Lock()
	defer fake.createNetworkMutex.Unlock()
	fake.CreateNetworkStub = nil
	if fake.createNetworkReturnsOnCall == nil {
		fake.createNetworkReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkACL(arg1 api.NetworkACLsPost) error {
	fake.createNetworkACLMutex.Lock()
	ret, specificReturn := fake.createNetworkACLReturnsOnCall[len(fake.createNetworkACLArgsForCall)]
	fake.createNetworkACLArgsForCall = append(fake.createNetworkACLArgsForCall, struct {
		arg1 api.NetworkACLsPost
	}{arg1})
	stub := fake.CreateNetworkACLStub
	fakeReturns := fake.createNetworkACLReturns
	fake.recordInvocation("CreateNetworkACL", []interface{}{arg1})
	fake.createNetworkACLMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkACLCallCount() int {
	fake.createNetworkACLMutex.RLock()
	defer fake.createNetworkACLMutex.RUnlock()
	return len(fake.createNetworkACLArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkACLCalls(stub func(api.NetworkACLsPost) error) {
	fake.createNetworkACLMutex.Lock()
	defer fake.createNetworkACLMutex.Unlock()
	fake.CreateNetworkACLStub = stub
}

func (fake *FakeContainerServer) CreateNetworkACLArgsForCall(i int) api.NetworkACLsPost {
	fake.createNetworkACLMutex.RLock()
	defer fake.createNetworkACLMutex.RUnlock()
	argsForCall := fake.createNetworkACLArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateNetworkACLReturns(result1 error) {
	fake.createNetworkACLMutex.Lock()
	defer fake.createNetworkACLMutex.Unlock()
	fake.CreateNetworkACLStub = nil
	fake.createNetworkACLReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkACLReturnsOnCall(i int, result1 error) {
	fake.createNetworkACLMutex.Lock()
	defer fake.createNetworkACLMutex.Unlock()
	fake.CreateNetworkACLStub = nil
	if fake.createNetworkACLReturnsOnCall == nil {
		fake.createNetworkACLReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkACLReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkForward(arg1 string, arg2 api.NetworkForwardsPost) error {
	fake.createNetworkForwardMutex.Lock()
	ret, specificReturn := fake.createNetworkForwardReturnsOnCall[len(fake.createNetworkForwardArgsForCall)]
	fake.createNetworkForwardArgsForCall = append(fake.createNetworkForwardArgsForCall, struct {
		arg1 string
		arg2 api.NetworkForwardsPost
	}{arg1, arg2})
	stub := fake.CreateNetworkForwardStub
	fakeReturns := fake.createNetworkForwardReturns
	fake.recordInvocation("CreateNetworkForward", []interface{}{arg1, arg2})
	fake.createNetworkForwardMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkForwardCallCount() int {
	fake.createNetworkForwardMutex.RLock()
	defer fake.createNetworkForwardMutex.RUnlock()
	return len(fake.createNetworkForwardArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkForwardCalls(stub func(string, api.NetworkForwardsPost) error) {
	fake.createNetworkForwardMutex.Lock()
	defer fake.createNetworkForwardMutex.Unlock()
	fake.CreateNetworkForwardStub = stub
}

func (fake *FakeContainerServer) CreateNetworkForwardArgsForCall(i int) (string, api.NetworkForwardsPost) {
	fake.createNetworkForwardMutex.RLock()
	defer fake.createNetworkForwardMutex.RUnlock()
	argsForCall := fake.createNetworkForwardArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateNetworkForwardReturns(result1 error) {
	fake.createNetworkForwardMutex.Lock()
	defer fake.createNetworkForwardMutex.Unlock()
	fake.CreateNetworkForwardStub = nil
	fake.createNetworkForwardReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkForwardReturnsOnCall(i int, result1 error) {
	fake.createNetworkForwardMutex.Lock()
	defer fake.createNetworkForwardMutex.Unlock()
	fake.CreateNetworkForwardStub = nil
	if fake.createNetworkForwardReturnsOnCall == nil {
		fake.createNetworkForwardReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkForwardReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancer(arg1 string, arg2 api.NetworkLoadBalancersPost) error {
	fake.createNetworkLoadBalancerMutex.Lock()
	ret, specificReturn := fake.createNetworkLoadBalancerReturnsOnCall[len(fake.createNetworkLoadBalancerArgsForCall)]
	fake.createNetworkLoadBalancerArgsForCall = append(fake.createNetworkLoadBalancerArgsForCall, struct {
		arg1 string
		arg2 api.NetworkLoadBalancersPost
	}{arg1, arg2})
	stub := fake.CreateNetworkLoadBalancerStub
	fakeReturns := fake.createNetworkLoadBalancerReturns
	fake.recordInvocation("CreateNetworkLoadBalancer", []interface{}{arg1, arg2})
	fake.createNetworkLoadBalancerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancerCallCount() int {
	fake.createNetworkLoadBalancerMutex.RLock()
	defer fake.createNetworkLoadBalancerMutex.RUnlock()
	return len(fake.createNetworkLoadBalancerArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancerCalls(stub func(string, api.NetworkLoadBalancersPost) error) {
	fake.createNetworkLoadBalancerMutex.Lock()
	defer fake.createNetworkLoadBalancerMutex.Unlock()
	fake.CreateNetworkLoadBalancerStub = stub
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancerArgsForCall(i int) (string, api.NetworkLoadBalancersPost) {
	fake.createNetworkLoadBalancerMutex.RLock()
	defer fake.createNetworkLoadBalancerMutex.RUnlock()
	argsForCall := fake.createNetworkLoadBalancerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancerReturns(result1 error) {
	fake.createNetworkLoadBalancerMutex.Lock()
	defer fake.createNetworkLoadBalancerMutex.Unlock()
	fake.CreateNetworkLoadBalancerStub = nil
	fake.createNetworkLoadBalancerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkLoadBalancerReturnsOnCall(i int, result1 error) {
	fake.createNetworkLoadBalancerMutex.Lock()
	defer fake.createNetworkLoadBalancerMutex.Unlock()
	fake.CreateNetworkLoadBalancerStub = nil
	if fake.createNetworkLoadBalancerReturnsOnCall == nil {
		fake.createNetworkLoadBalancerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkLoadBalancerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkPeer(arg1 string, arg2 api.NetworkPeersPost) error {
	fake.createNetworkPeerMutex.Lock()
	ret, specificReturn := fake.createNetworkPeerReturnsOnCall[len(fake.createNetworkPeerArgsForCall)]
	fake.createNetworkPeerArgsForCall = append(fake.createNetworkPeerArgsForCall, struct {
		arg1 string
		arg2 api.NetworkPeersPost
	}{arg1, arg2})
	stub := fake.CreateNetworkPeerStub
	fakeReturns := fake.createNetworkPeerReturns
	fake.recordInvocation("CreateNetworkPeer", []interface{}{arg1, arg2})
	fake.createNetworkPeerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkPeerCallCount() int {
	fake.createNetworkPeerMutex.RLock()
	defer fake.createNetworkPeerMutex.RUnlock()
	return len(fake.createNetworkPeerArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkPeerCalls(stub func(string, api.NetworkPeersPost) error) {
	fake.createNetworkPeerMutex.Lock()
	defer fake.createNetworkPeerMutex.Unlock()
	fake.CreateNetworkPeerStub = stub
}

func (fake *FakeContainerServer) CreateNetworkPeerArgsForCall(i int) (string, api.NetworkPeersPost) {
	fake.createNetworkPeerMutex.RLock()
	defer fake.createNetworkPeerMutex.RUnlock()
	argsForCall := fake.createNetworkPeerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateNetworkPeerReturns(result1 error) {
	fake.createNetworkPeerMutex.Lock()
	defer fake.createNetworkPeerMutex.Unlock()
	fake.CreateNetworkPeerStub = nil
	fake.createNetworkPeerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkPeerReturnsOnCall(i int, result1 error) {
	fake.createNetworkPeerMutex.Lock()
	defer fake.createNetworkPeerMutex.Unlock()
	fake.CreateNetworkPeerStub = nil
	if fake.createNetworkPeerReturnsOnCall == nil {
		fake.createNetworkPeerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkPeerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkZone(arg1 api.NetworkZonesPost) error {
	fake.createNetworkZoneMutex.Lock()
	ret, specificReturn := fake.createNetworkZoneReturnsOnCall[len(fake.createNetworkZoneArgsForCall)]
	fake.createNetworkZoneArgsForCall = append(fake.createNetworkZoneArgsForCall, struct {
		arg1 api.NetworkZonesPost
	}{arg1})
	stub := fake.CreateNetworkZoneStub
	fakeReturns := fake.createNetworkZoneReturns
	fake.recordInvocation("CreateNetworkZone", []interface{}{arg1})
	fake.createNetworkZoneMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkZoneCallCount() int {
	fake.createNetworkZoneMutex.RLock()
	defer fake.createNetworkZoneMutex.RUnlock()
	return len(fake.createNetworkZoneArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkZoneCalls(stub func(api.NetworkZonesPost) error) {
	fake.createNetworkZoneMutex.Lock()
	defer fake.createNetworkZoneMutex.Unlock()
	fake.CreateNetworkZoneStub = stub
}

func (fake *FakeContainerServer) CreateNetworkZoneArgsForCall(i int) api.NetworkZonesPost {
	fake.createNetworkZoneMutex.RLock()
	defer fake.createNetworkZoneMutex.RUnlock()
	argsForCall := fake.createNetworkZoneArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateNetworkZoneReturns(result1 error) {
	fake.createNetworkZoneMutex.Lock()
	defer fake.createNetworkZoneMutex.Unlock()
	fake.CreateNetworkZoneStub = nil
	fake.createNetworkZoneReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkZoneReturnsOnCall(i int, result1 error) {
	fake.createNetworkZoneMutex.Lock()
	defer fake.createNetworkZoneMutex.Unlock()
	fake.CreateNetworkZoneStub = nil
	if fake.createNetworkZoneReturnsOnCall == nil {
		fake.createNetworkZoneReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkZoneReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkZoneRecord(arg1 string, arg2 api.NetworkZoneRecordsPost) error {
	fake.createNetworkZoneRecordMutex.Lock()
	ret, specificReturn := fake.createNetworkZoneRecordReturnsOnCall[len(fake.createNetworkZoneRecordArgsForCall)]
	fake.createNetworkZoneRecordArgsForCall = append(fake.createNetworkZoneRecordArgsForCall, struct {
		arg1 string
		arg2 api.NetworkZoneRecordsPost
	}{arg1, arg2})
	stub := fake.CreateNetworkZoneRecordStub
	fakeReturns := fake.createNetworkZoneRecordReturns
	fake.recordInvocation("CreateNetworkZoneRecord", []interface{}{arg1, arg2})
	fake.createNetworkZoneRecordMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateNetworkZoneRecordCallCount() int {
	fake.createNetworkZoneRecordMutex.RLock()
	defer fake.createNetworkZoneRecordMutex.RUnlock()
	return len(fake.createNetworkZoneRecordArgsForCall)
}

func (fake *FakeContainerServer) CreateNetworkZoneRecordCalls(stub func(string, api.NetworkZoneRecordsPost) error) {
	fake.createNetworkZoneRecordMutex.Lock()
	defer fake.createNetworkZoneRecordMutex.Unlock()
	fake.CreateNetworkZoneRecordStub = stub
}

func (fake *FakeContainerServer) CreateNetworkZoneRecordArgsForCall(i int) (string, api.NetworkZoneRecordsPost) {
	fake.createNetworkZoneRecordMutex.RLock()
	defer fake.createNetworkZoneRecordMutex.RUnlock()
	argsForCall := fake.createNetworkZoneRecordArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateNetworkZoneRecordReturns(result1 error) {
	fake.createNetworkZoneRecordMutex.Lock()
	defer fake.createNetworkZoneRecordMutex.Unlock()
	fake.CreateNetworkZoneRecordStub = nil
	fake.createNetworkZoneRecordReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateNetworkZoneRecordReturnsOnCall(i int, result1 error) {
	fake.createNetworkZoneRecordMutex.Lock()
	defer fake.createNetworkZoneRecordMutex.Unlock()
	fake.CreateNetworkZoneRecordStub = nil
	if fake.createNetworkZoneRecordReturnsOnCall == nil {
		fake.createNetworkZoneRecordReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createNetworkZoneRecordReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateProfile(arg1 api.ProfilesPost) error {
	fake.createProfileMutex.Lock()
	ret, specificReturn := fake.createProfileReturnsOnCall[len(fake.createProfileArgsForCall)]
	fake.createProfileArgsForCall = append(fake.createProfileArgsForCall, struct {
		arg1 api.ProfilesPost
	}{arg1})
	stub := fake.CreateProfileStub
	fakeReturns := fake.createProfileReturns
	fake.recordInvocation("CreateProfile", []interface{}{arg1})
	fake.createProfileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateProfileCallCount() int {
	fake.createProfileMutex.RLock()
	defer fake.createProfileMutex.RUnlock()
	return len(fake.createProfileArgsForCall)
}

func (fake *FakeContainerServer) CreateProfileCalls(stub func(api.ProfilesPost) error) {
	fake.createProfileMutex.Lock()
	defer fake.createProfileMutex.Unlock()
	fake.CreateProfileStub = stub
}

func (fake *FakeContainerServer) CreateProfileArgsForCall(i int) api.ProfilesPost {
	fake.createProfileMutex.RLock()
	defer fake.createProfileMutex.RUnlock()
	argsForCall := fake.createProfileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateProfileReturns(result1 error) {
	fake.createProfileMutex.Lock()
	defer fake.createProfileMutex.Unlock()
	fake.CreateProfileStub = nil
	fake.createProfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateProfileReturnsOnCall(i int, result1 error) {
	fake.createProfileMutex.Lock()
	defer fake.createProfileMutex.Unlock()
	fake.CreateProfileStub = nil
	if fake.createProfileReturnsOnCall == nil {
		fake.createProfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createProfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateProject(arg1 api.ProjectsPost) error {
	fake.createProjectMutex.Lock()
	ret, specificReturn := fake.createProjectReturnsOnCall[len(fake.createProjectArgsForCall)]
	fake.createProjectArgsForCall = append(fake.createProjectArgsForCall, struct {
		arg1 api.ProjectsPost
	}{arg1})
	stub := fake.CreateProjectStub
	fakeReturns := fake.createProjectReturns
	fake.recordInvocation("CreateProject", []interface{}{arg1})
	fake.createProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateProjectCallCount() int {
	fake.createProjectMutex.RLock()
	defer fake.createProjectMutex.RUnlock()
	return len(fake.createProjectArgsForCall)
}

func (fake *FakeContainerServer) CreateProjectCalls(stub func(api.ProjectsPost) error) {
	fake.createProjectMutex.Lock()
	defer fake.createProjectMutex.Unlock()
	fake.CreateProjectStub = stub
}

func (fake *FakeContainerServer) CreateProjectArgsForCall(i int) api.ProjectsPost {
	fake.createProjectMutex.RLock()
	defer fake.createProjectMutex.RUnlock()
	argsForCall := fake.createProjectArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateProjectReturns(result1 error) {
	fake.createProjectMutex.Lock()
	defer fake.createProjectMutex.Unlock()
	fake.CreateProjectStub = nil
	fake.createProjectReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateProjectReturnsOnCall(i int, result1 error) {
	fake.createProjectMutex.Lock()
	defer fake.createProjectMutex.Unlock()
	fake.CreateProjectStub = nil
	if fake.createProjectReturnsOnCall == nil {
		fake.createProjectReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createProjectReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateStoragePool(arg1 api.StoragePoolsPost) error {
	fake.createStoragePoolMutex.Lock()
	ret, specificReturn := fake.createStoragePoolReturnsOnCall[len(fake.createStoragePoolArgsForCall)]
	fake.createStoragePoolArgsForCall = append(fake.createStoragePoolArgsForCall, struct {
		arg1 api.StoragePoolsPost
	}{arg1})
	stub := fake.CreateStoragePoolStub
	fakeReturns := fake.createStoragePoolReturns
	fake.recordInvocation("CreateStoragePool", []interface{}{arg1})
	fake.createStoragePoolMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateStoragePoolCallCount() int {
	fake.createStoragePoolMutex.RLock()
	defer fake.createStoragePoolMutex.RUnlock()
	return len(fake.createStoragePoolArgsForCall)
}

func (fake *FakeContainerServer) CreateStoragePoolCalls(stub func(api.StoragePoolsPost) error) {
	fake.createStoragePoolMutex.Lock()
	defer fake.createStoragePoolMutex.Unlock()
	fake.CreateStoragePoolStub = stub
}

func (fake *FakeContainerServer) CreateStoragePoolArgsForCall(i int) api.StoragePoolsPost {
	fake.createStoragePoolMutex.RLock()
	defer fake.createStoragePoolMutex.RUnlock()
	argsForCall := fake.createStoragePoolArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) CreateStoragePoolReturns(result1 error) {
	fake.createStoragePoolMutex.Lock()
	defer fake.createStoragePoolMutex.Unlock()
	fake.CreateStoragePoolStub = nil
	fake.createStoragePoolReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateStoragePoolReturnsOnCall(i int, result1 error) {
	fake.createStoragePoolMutex.Lock()
	defer fake.createStoragePoolMutex.Unlock()
	fake.CreateStoragePoolStub = nil
	if fake.createStoragePoolReturnsOnCall == nil {
		fake.createStoragePoolReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createStoragePoolReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateStoragePoolVolume(arg1 string, arg2 api.StorageVolumesPost) error {
	fake.createStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.createStoragePoolVolumeReturnsOnCall[len(fake.createStoragePoolVolumeArgsForCall)]
	fake.createStoragePoolVolumeArgsForCall = append(fake.createStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 api.StorageVolumesPost
	}{arg1, arg2})
	stub := fake.CreateStoragePoolVolumeStub
	fakeReturns := fake.createStoragePoolVolumeReturns
	fake.recordInvocation("CreateStoragePoolVolume", []interface{}{arg1, arg2})
	fake.createStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeCallCount() int {
	fake.createStoragePoolVolumeMutex.RLock()
	defer fake.createStoragePoolVolumeMutex.RUnlock()
	return len(fake.createStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeCalls(stub func(string, api.StorageVolumesPost) error) {
	fake.createStoragePoolVolumeMutex.Lock()
	defer fake.createStoragePoolVolumeMutex.Unlock()
	fake.CreateStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeArgsForCall(i int) (string, api.StorageVolumesPost) {
	fake.createStoragePoolVolumeMutex.RLock()
	defer fake.createStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.createStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeReturns(result1 error) {
	fake.createStoragePoolVolumeMutex.Lock()
	defer fake.createStoragePoolVolumeMutex.Unlock()
	fake.CreateStoragePoolVolumeStub = nil
	fake.createStoragePoolVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeReturnsOnCall(i int, result1 error) {
	fake.createStoragePoolVolumeMutex.Lock()
	defer fake.createStoragePoolVolumeMutex.Unlock()
	fake.CreateStoragePoolVolumeStub = nil
	if fake.createStoragePoolVolumeReturnsOnCall == nil {
		fake.createStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackup(arg1 string, arg2 string, arg3 api.StoragePoolVolumeBackupsPost) (lxd.Operation, error) {
	fake.createStoragePoolVolumeBackupMutex.Lock()
	ret, specificReturn := fake.createStoragePoolVolumeBackupReturnsOnCall[len(fake.createStoragePoolVolumeBackupArgsForCall)]
	fake.createStoragePoolVolumeBackupArgsForCall = append(fake.createStoragePoolVolumeBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.StoragePoolVolumeBackupsPost
	}{arg1, arg2, arg3})
	stub := fake.CreateStoragePoolVolumeBackupStub
	fakeReturns := fake.createStoragePoolVolumeBackupReturns
	fake.recordInvocation("CreateStoragePoolVolumeBackup", []interface{}{arg1, arg2, arg3})
	fake.createStoragePoolVolumeBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackupCallCount() int {
	fake.createStoragePoolVolumeBackupMutex.RLock()
	defer fake.createStoragePoolVolumeBackupMutex.RUnlock()
	return len(fake.createStoragePoolVolumeBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackupCalls(stub func(string, string, api.StoragePoolVolumeBackupsPost) (lxd.Operation, error)) {
	fake.createStoragePoolVolumeBackupMutex.Lock()
	defer fake.createStoragePoolVolumeBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeBackupStub = stub
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackupArgsForCall(i int) (string, string, api.StoragePoolVolumeBackupsPost) {
	fake.createStoragePoolVolumeBackupMutex.RLock()
	defer fake.createStoragePoolVolumeBackupMutex.RUnlock()
	argsForCall := fake.createStoragePoolVolumeBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeBackupMutex.Lock()
	defer fake.createStoragePoolVolumeBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeBackupStub = nil
	fake.createStoragePoolVolumeBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeBackupMutex.Lock()
	defer fake.createStoragePoolVolumeBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeBackupStub = nil
	if fake.createStoragePoolVolumeBackupReturnsOnCall == nil {
		fake.createStoragePoolVolumeBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createStoragePoolVolumeBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackup(arg1 string, arg2 lxd.StoragePoolVolumeBackupArgs) (lxd.Operation, error) {
	fake.createStoragePoolVolumeFromBackupMutex.Lock()
	ret, specificReturn := fake.createStoragePoolVolumeFromBackupReturnsOnCall[len(fake.createStoragePoolVolumeFromBackupArgsForCall)]
	fake.createStoragePoolVolumeFromBackupArgsForCall = append(fake.createStoragePoolVolumeFromBackupArgsForCall, struct {
		arg1 string
		arg2 lxd.StoragePoolVolumeBackupArgs
	}{arg1, arg2})
	stub := fake.CreateStoragePoolVolumeFromBackupStub
	fakeReturns := fake.createStoragePoolVolumeFromBackupReturns
	fake.recordInvocation("CreateStoragePoolVolumeFromBackup", []interface{}{arg1, arg2})
	fake.createStoragePoolVolumeFromBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackupCallCount() int {
	fake.createStoragePoolVolumeFromBackupMutex.RLock()
	defer fake.createStoragePoolVolumeFromBackupMutex.RUnlock()
	return len(fake.createStoragePoolVolumeFromBackupArgsForCall)
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackupCalls(stub func(string, lxd.StoragePoolVolumeBackupArgs) (lxd.Operation, error)) {
	fake.createStoragePoolVolumeFromBackupMutex.Lock()
	defer fake.createStoragePoolVolumeFromBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeFromBackupStub = stub
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackupArgsForCall(i int) (string, lxd.StoragePoolVolumeBackupArgs) {
	fake.createStoragePoolVolumeFromBackupMutex.RLock()
	defer fake.createStoragePoolVolumeFromBackupMutex.RUnlock()
	argsForCall := fake.createStoragePoolVolumeFromBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackupReturns(result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeFromBackupMutex.Lock()
	defer fake.createStoragePoolVolumeFromBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeFromBackupStub = nil
	fake.createStoragePoolVolumeFromBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeFromBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeFromBackupMutex.Lock()
	defer fake.createStoragePoolVolumeFromBackupMutex.Unlock()
	fake.CreateStoragePoolVolumeFromBackupStub = nil
	if fake.createStoragePoolVolumeFromBackupReturnsOnCall == nil {
		fake.createStoragePoolVolumeFromBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createStoragePoolVolumeFromBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshot(arg1 string, arg2 string, arg3 string, arg4 api.StorageVolumeSnapshotsPost) (lxd.Operation, error) {
	fake.createStoragePoolVolumeSnapshotMutex.Lock()
	ret, specificReturn := fake.createStoragePoolVolumeSnapshotReturnsOnCall[len(fake.createStoragePoolVolumeSnapshotArgsForCall)]
	fake.createStoragePoolVolumeSnapshotArgsForCall = append(fake.createStoragePoolVolumeSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumeSnapshotsPost
	}{arg1, arg2, arg3, arg4})
	stub := fake.CreateStoragePoolVolumeSnapshotStub
	fakeReturns := fake.createStoragePoolVolumeSnapshotReturns
	fake.recordInvocation("CreateStoragePoolVolumeSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.createStoragePoolVolumeSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshotCallCount() int {
	fake.createStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.createStoragePoolVolumeSnapshotMutex.RUnlock()
	return len(fake.createStoragePoolVolumeSnapshotArgsForCall)
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshotCalls(stub func(string, string, string, api.StorageVolumeSnapshotsPost) (lxd.Operation, error)) {
	fake.createStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.createStoragePoolVolumeSnapshotMutex.Unlock()
	fake.CreateStoragePoolVolumeSnapshotStub = stub
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshotArgsForCall(i int) (string, string, string, api.StorageVolumeSnapshotsPost) {
	fake.createStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.createStoragePoolVolumeSnapshotMutex.RUnlock()
	argsForCall := fake.createStoragePoolVolumeSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.createStoragePoolVolumeSnapshotMutex.Unlock()
	fake.CreateStoragePoolVolumeSnapshotStub = nil
	fake.createStoragePoolVolumeSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) CreateStoragePoolVolumeSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.createStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.createStoragePoolVolumeSnapshotMutex.Unlock()
	fake.CreateStoragePoolVolumeSnapshotStub = nil
	if fake.createStoragePoolVolumeSnapshotReturnsOnCall == nil {
		fake.createStoragePoolVolumeSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.createStoragePoolVolumeSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteCertificate(arg1 string) error {
	fake.deleteCertificateMutex.Lock()
	ret, specificReturn := fake.deleteCertificateReturnsOnCall[len(fake.deleteCertificateArgsForCall)]
	fake.deleteCertificateArgsForCall = append(fake.deleteCertificateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteCertificateStub
	fakeReturns := fake.deleteCertificateReturns
	fake.recordInvocation("DeleteCertificate", []interface{}{arg1})
	fake.deleteCertificateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteCertificateCallCount() int {
	fake.deleteCertificateMutex.RLock()
	defer fake.deleteCertificateMutex.RUnlock()
	return len(fake.deleteCertificateArgsForCall)
}

func (fake *FakeContainerServer) DeleteCertificateCalls(stub func(string) error) {
	fake.deleteCertificateMutex.Lock()
	defer fake.deleteCertificateMutex.Unlock()
	fake.DeleteCertificateStub = stub
}

func (fake *FakeContainerServer) DeleteCertificateArgsForCall(i int) string {
	fake.deleteCertificateMutex.RLock()
	defer fake.deleteCertificateMutex.RUnlock()
	argsForCall := fake.deleteCertificateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteCertificateReturns(result1 error) {
	fake.deleteCertificateMutex.Lock()
	defer fake.deleteCertificateMutex.Unlock()
	fake.DeleteCertificateStub = nil
	fake.deleteCertificateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteCertificateReturnsOnCall(i int, result1 error) {
	fake.deleteCertificateMutex.Lock()
	defer fake.deleteCertificateMutex.Unlock()
	fake.DeleteCertificateStub = nil
	if fake.deleteCertificateReturnsOnCall == nil {
		fake.deleteCertificateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteCertificateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteClusterGroup(arg1 string) error {
	fake.deleteClusterGroupMutex.Lock()
	ret, specificReturn := fake.deleteClusterGroupReturnsOnCall[len(fake.deleteClusterGroupArgsForCall)]
	fake.deleteClusterGroupArgsForCall = append(fake.deleteClusterGroupArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteClusterGroupStub
	fakeReturns := fake.deleteClusterGroupReturns
	fake.recordInvocation("DeleteClusterGroup", []interface{}{arg1})
	fake.deleteClusterGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteClusterGroupCallCount() int {
	fake.deleteClusterGroupMutex.RLock()
	defer fake.deleteClusterGroupMutex.RUnlock()
	return len(fake.deleteClusterGroupArgsForCall)
}

func (fake *FakeContainerServer) DeleteClusterGroupCalls(stub func(string) error) {
	fake.deleteClusterGroupMutex.Lock()
	defer fake.deleteClusterGroupMutex.Unlock()
	fake.DeleteClusterGroupStub = stub
}

func (fake *FakeContainerServer) DeleteClusterGroupArgsForCall(i int) string {
	fake.deleteClusterGroupMutex.RLock()
	defer fake.deleteClusterGroupMutex.RUnlock()
	argsForCall := fake.deleteClusterGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteClusterGroupReturns(result1 error) {
	fake.deleteClusterGroupMutex.Lock()
	defer fake.deleteClusterGroupMutex.Unlock()
	fake.DeleteClusterGroupStub = nil
	fake.deleteClusterGroupReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteClusterGroupReturnsOnCall(i int, result1 error) {
	fake.deleteClusterGroupMutex.Lock()
	defer fake.deleteClusterGroupMutex.Unlock()
	fake.DeleteClusterGroupStub = nil
	if fake.deleteClusterGroupReturnsOnCall == nil {
		fake.deleteClusterGroupReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteClusterGroupReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteClusterMember(arg1 string, arg2 bool) error {
	fake.deleteClusterMemberMutex.Lock()
	ret, specificReturn := fake.deleteClusterMemberReturnsOnCall[len(fake.deleteClusterMemberArgsForCall)]
	fake.deleteClusterMemberArgsForCall = append(fake.deleteClusterMemberArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	stub := fake.DeleteClusterMemberStub
	fakeReturns := fake.deleteClusterMemberReturns
	fake.recordInvocation("DeleteClusterMember", []interface{}{arg1, arg2})
	fake.deleteClusterMemberMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteClusterMemberCallCount() int {
	fake.deleteClusterMemberMutex.RLock()
	defer fake.deleteClusterMemberMutex.RUnlock()
	return len(fake.deleteClusterMemberArgsForCall)
}

func (fake *FakeContainerServer) DeleteClusterMemberCalls(stub func(string, bool) error) {
	fake.deleteClusterMemberMutex.Lock()
	defer fake.deleteClusterMemberMutex.Unlock()
	fake.DeleteClusterMemberStub = stub
}

func (fake *FakeContainerServer) DeleteClusterMemberArgsForCall(i int) (string, bool) {
	fake.deleteClusterMemberMutex.RLock()
	defer fake.deleteClusterMemberMutex.RUnlock()
	argsForCall := fake.deleteClusterMemberArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteClusterMemberReturns(result1 error) {
	fake.deleteClusterMemberMutex.Lock()
	defer fake.deleteClusterMemberMutex.Unlock()
	fake.DeleteClusterMemberStub = nil
	fake.deleteClusterMemberReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteClusterMemberReturnsOnCall(i int, result1 error) {
	fake.deleteClusterMemberMutex.Lock()
	defer fake.deleteClusterMemberMutex.Unlock()
	fake.DeleteClusterMemberStub = nil
	if fake.deleteClusterMemberReturnsOnCall == nil {
		fake.deleteClusterMemberReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteClusterMemberReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainer(arg1 string) (lxd.Operation, error) {
	fake.deleteContainerMutex.Lock()
	ret, specificReturn := fake.deleteContainerReturnsOnCall[len(fake.deleteContainerArgsForCall)]
	fake.deleteContainerArgsForCall = append(fake.deleteContainerArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteContainerStub
	fakeReturns := fake.deleteContainerReturns
	fake.recordInvocation("DeleteContainer", []interface{}{arg1})
	fake.deleteContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteContainerCallCount() int {
	fake.deleteContainerMutex.RLock()
	defer fake.deleteContainerMutex.RUnlock()
	return len(fake.deleteContainerArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerCalls(stub func(string) (lxd.Operation, error)) {
	fake.deleteContainerMutex.Lock()
	defer fake.deleteContainerMutex.Unlock()
	fake.DeleteContainerStub = stub
}

func (fake *FakeContainerServer) DeleteContainerArgsForCall(i int) string {
	fake.deleteContainerMutex.RLock()
	defer fake.deleteContainerMutex.RUnlock()
	argsForCall := fake.deleteContainerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteContainerReturns(result1 lxd.Operation, result2 error) {
	fake.deleteContainerMutex.Lock()
	defer fake.deleteContainerMutex.Unlock()
	fake.DeleteContainerStub = nil
	fake.deleteContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteContainerMutex.Lock()
	defer fake.deleteContainerMutex.Unlock()
	fake.DeleteContainerStub = nil
	if fake.deleteContainerReturnsOnCall == nil {
		fake.deleteContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerBackup(arg1 string, arg2 string) (lxd.Operation, error) {
	fake.deleteContainerBackupMutex.Lock()
	ret, specificReturn := fake.deleteContainerBackupReturnsOnCall[len(fake.deleteContainerBackupArgsForCall)]
	fake.deleteContainerBackupArgsForCall = append(fake.deleteContainerBackupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteContainerBackupStub
	fakeReturns := fake.deleteContainerBackupReturns
	fake.recordInvocation("DeleteContainerBackup", []interface{}{arg1, arg2})
	fake.deleteContainerBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteContainerBackupCallCount() int {
	fake.deleteContainerBackupMutex.RLock()
	defer fake.deleteContainerBackupMutex.RUnlock()
	return len(fake.deleteContainerBackupArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerBackupCalls(stub func(string, string) (lxd.Operation, error)) {
	fake.deleteContainerBackupMutex.Lock()
	defer fake.deleteContainerBackupMutex.Unlock()
	fake.DeleteContainerBackupStub = stub
}

func (fake *FakeContainerServer) DeleteContainerBackupArgsForCall(i int) (string, string) {
	fake.deleteContainerBackupMutex.RLock()
	defer fake.deleteContainerBackupMutex.RUnlock()
	argsForCall := fake.deleteContainerBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerBackupReturns(result1 lxd.Operation, result2 error) {
	fake.deleteContainerBackupMutex.Lock()
	defer fake.deleteContainerBackupMutex.Unlock()
	fake.DeleteContainerBackupStub = nil
	fake.deleteContainerBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteContainerBackupMutex.Lock()
	defer fake.deleteContainerBackupMutex.Unlock()
	fake.DeleteContainerBackupStub = nil
	if fake.deleteContainerBackupReturnsOnCall == nil {
		fake.deleteContainerBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteContainerBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerConsoleLog(arg1 string, arg2 *lxd.ContainerConsoleLogArgs) error {
	fake.deleteContainerConsoleLogMutex.Lock()
	ret, specificReturn := fake.deleteContainerConsoleLogReturnsOnCall[len(fake.deleteContainerConsoleLogArgsForCall)]
	fake.deleteContainerConsoleLogArgsForCall = append(fake.deleteContainerConsoleLogArgsForCall, struct {
		arg1 string
		arg2 *lxd.ContainerConsoleLogArgs
	}{arg1, arg2})
	stub := fake.DeleteContainerConsoleLogStub
	fakeReturns := fake.deleteContainerConsoleLogReturns
	fake.recordInvocation("DeleteContainerConsoleLog", []interface{}{arg1, arg2})
	fake.deleteContainerConsoleLogMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteContainerConsoleLogCallCount() int {
	fake.deleteContainerConsoleLogMutex.RLock()
	defer fake.deleteContainerConsoleLogMutex.RUnlock()
	return len(fake.deleteContainerConsoleLogArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerConsoleLogCalls(stub func(string, *lxd.ContainerConsoleLogArgs) error) {
	fake.deleteContainerConsoleLogMutex.Lock()
	defer fake.deleteContainerConsoleLogMutex.Unlock()
	fake.DeleteContainerConsoleLogStub = stub
}

func (fake *FakeContainerServer) DeleteContainerConsoleLogArgsForCall(i int) (string, *lxd.ContainerConsoleLogArgs) {
	fake.deleteContainerConsoleLogMutex.RLock()
	defer fake.deleteContainerConsoleLogMutex.RUnlock()
	argsForCall := fake.deleteContainerConsoleLogArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerConsoleLogReturns(result1 error) {
	fake.deleteContainerConsoleLogMutex.Lock()
	defer fake.deleteContainerConsoleLogMutex.Unlock()
	fake.DeleteContainerConsoleLogStub = nil
	fake.deleteContainerConsoleLogReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerConsoleLogReturnsOnCall(i int, result1 error) {
	fake.deleteContainerConsoleLogMutex.Lock()
	defer fake.deleteContainerConsoleLogMutex.Unlock()
	fake.DeleteContainerConsoleLogStub = nil
	if fake.deleteContainerConsoleLogReturnsOnCall == nil {
		fake.deleteContainerConsoleLogReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteContainerConsoleLogReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerFile(arg1 string, arg2 string) error {
	fake.deleteContainerFileMutex.Lock()
	ret, specificReturn := fake.deleteContainerFileReturnsOnCall[len(fake.deleteContainerFileArgsForCall)]
	fake.deleteContainerFileArgsForCall = append(fake.deleteContainerFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteContainerFileStub
	fakeReturns := fake.deleteContainerFileReturns
	fake.recordInvocation("DeleteContainerFile", []interface{}{arg1, arg2})
	fake.deleteContainerFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteContainerFileCallCount() int {
	fake.deleteContainerFileMutex.RLock()
	defer fake.deleteContainerFileMutex.RUnlock()
	return len(fake.deleteContainerFileArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerFileCalls(stub func(string, string) error) {
	fake.deleteContainerFileMutex.Lock()
	defer fake.deleteContainerFileMutex.Unlock()
	fake.DeleteContainerFileStub = stub
}

func (fake *FakeContainerServer) DeleteContainerFileArgsForCall(i int) (string, string) {
	fake.deleteContainerFileMutex.RLock()
	defer fake.deleteContainerFileMutex.RUnlock()
	argsForCall := fake.deleteContainerFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerFileReturns(result1 error) {
	fake.deleteContainerFileMutex.Lock()
	defer fake.deleteContainerFileMutex.Unlock()
	fake.DeleteContainerFileStub = nil
	fake.deleteContainerFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerFileReturnsOnCall(i int, result1 error) {
	fake.deleteContainerFileMutex.Lock()
	defer fake.deleteContainerFileMutex.Unlock()
	fake.DeleteContainerFileStub = nil
	if fake.deleteContainerFileReturnsOnCall == nil {
		fake.deleteContainerFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteContainerFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerLogfile(arg1 string, arg2 string) error {
	fake.deleteContainerLogfileMutex.Lock()
	ret, specificReturn := fake.deleteContainerLogfileReturnsOnCall[len(fake.deleteContainerLogfileArgsForCall)]
	fake.deleteContainerLogfileArgsForCall = append(fake.deleteContainerLogfileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteContainerLogfileStub
	fakeReturns := fake.deleteContainerLogfileReturns
	fake.recordInvocation("DeleteContainerLogfile", []interface{}{arg1, arg2})
	fake.deleteContainerLogfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteContainerLogfileCallCount() int {
	fake.deleteContainerLogfileMutex.RLock()
	defer fake.deleteContainerLogfileMutex.RUnlock()
	return len(fake.deleteContainerLogfileArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerLogfileCalls(stub func(string, string) error) {
	fake.deleteContainerLogfileMutex.Lock()
	defer fake.deleteContainerLogfileMutex.Unlock()
	fake.DeleteContainerLogfileStub = stub
}

func (fake *FakeContainerServer) DeleteContainerLogfileArgsForCall(i int) (string, string) {
	fake.deleteContainerLogfileMutex.RLock()
	defer fake.deleteContainerLogfileMutex.RUnlock()
	argsForCall := fake.deleteContainerLogfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerLogfileReturns(result1 error) {
	fake.deleteContainerLogfileMutex.Lock()
	defer fake.deleteContainerLogfileMutex.Unlock()
	fake.DeleteContainerLogfileStub = nil
	fake.deleteContainerLogfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerLogfileReturnsOnCall(i int, result1 error) {
	fake.deleteContainerLogfileMutex.Lock()
	defer fake.deleteContainerLogfileMutex.Unlock()
	fake.DeleteContainerLogfileStub = nil
	if fake.deleteContainerLogfileReturnsOnCall == nil {
		fake.deleteContainerLogfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteContainerLogfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerSnapshot(arg1 string, arg2 string) (lxd.Operation, error) {
	fake.deleteContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.deleteContainerSnapshotReturnsOnCall[len(fake.deleteContainerSnapshotArgsForCall)]
	fake.deleteContainerSnapshotArgsForCall = append(fake.deleteContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteContainerSnapshotStub
	fakeReturns := fake.deleteContainerSnapshotReturns
	fake.recordInvocation("DeleteContainerSnapshot", []interface{}{arg1, arg2})
	fake.deleteContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteContainerSnapshotCallCount() int {
	fake.deleteContainerSnapshotMutex.RLock()
	defer fake.deleteContainerSnapshotMutex.RUnlock()
	return len(fake.deleteContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerSnapshotCalls(stub func(string, string) (lxd.Operation, error)) {
	fake.deleteContainerSnapshotMutex.Lock()
	defer fake.deleteContainerSnapshotMutex.Unlock()
	fake.DeleteContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) DeleteContainerSnapshotArgsForCall(i int) (string, string) {
	fake.deleteContainerSnapshotMutex.RLock()
	defer fake.deleteContainerSnapshotMutex.RUnlock()
	argsForCall := fake.deleteContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.deleteContainerSnapshotMutex.Lock()
	defer fake.deleteContainerSnapshotMutex.Unlock()
	fake.DeleteContainerSnapshotStub = nil
	fake.deleteContainerSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteContainerSnapshotMutex.Lock()
	defer fake.deleteContainerSnapshotMutex.Unlock()
	fake.DeleteContainerSnapshotStub = nil
	if fake.deleteContainerSnapshotReturnsOnCall == nil {
		fake.deleteContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteContainerTemplateFile(arg1 string, arg2 string) error {
	fake.deleteContainerTemplateFileMutex.Lock()
	ret, specificReturn := fake.deleteContainerTemplateFileReturnsOnCall[len(fake.deleteContainerTemplateFileArgsForCall)]
	fake.deleteContainerTemplateFileArgsForCall = append(fake.deleteContainerTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteContainerTemplateFileStub
	fakeReturns := fake.deleteContainerTemplateFileReturns
	fake.recordInvocation("DeleteContainerTemplateFile", []interface{}{arg1, arg2})
	fake.deleteContainerTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteContainerTemplateFileCallCount() int {
	fake.deleteContainerTemplateFileMutex.RLock()
	defer fake.deleteContainerTemplateFileMutex.RUnlock()
	return len(fake.deleteContainerTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) DeleteContainerTemplateFileCalls(stub func(string, string) error) {
	fake.deleteContainerTemplateFileMutex.Lock()
	defer fake.deleteContainerTemplateFileMutex.Unlock()
	fake.DeleteContainerTemplateFileStub = stub
}

func (fake *FakeContainerServer) DeleteContainerTemplateFileArgsForCall(i int) (string, string) {
	fake.deleteContainerTemplateFileMutex.RLock()
	defer fake.deleteContainerTemplateFileMutex.RUnlock()
	argsForCall := fake.deleteContainerTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteContainerTemplateFileReturns(result1 error) {
	fake.deleteContainerTemplateFileMutex.Lock()
	defer fake.deleteContainerTemplateFileMutex.Unlock()
	fake.DeleteContainerTemplateFileStub = nil
	fake.deleteContainerTemplateFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteContainerTemplateFileReturnsOnCall(i int, result1 error) {
	fake.deleteContainerTemplateFileMutex.Lock()
	defer fake.deleteContainerTemplateFileMutex.Unlock()
	fake.DeleteContainerTemplateFileStub = nil
	if fake.deleteContainerTemplateFileReturnsOnCall == nil {
		fake.deleteContainerTemplateFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteContainerTemplateFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteImage(arg1 string) (lxd.Operation, error) {
	fake.deleteImageMutex.Lock()
	ret, specificReturn := fake.deleteImageReturnsOnCall[len(fake.deleteImageArgsForCall)]
	fake.deleteImageArgsForCall = append(fake.deleteImageArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteImageStub
	fakeReturns := fake.deleteImageReturns
	fake.recordInvocation("DeleteImage", []interface{}{arg1})
	fake.deleteImageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteImageCallCount() int {
	fake.deleteImageMutex.RLock()
	defer fake.deleteImageMutex.RUnlock()
	return len(fake.deleteImageArgsForCall)
}

func (fake *FakeContainerServer) DeleteImageCalls(stub func(string) (lxd.Operation, error)) {
	fake.deleteImageMutex.Lock()
	defer fake.deleteImageMutex.Unlock()
	fake.DeleteImageStub = stub
}

func (fake *FakeContainerServer) DeleteImageArgsForCall(i int) string {
	fake.deleteImageMutex.RLock()
	defer fake.deleteImageMutex.RUnlock()
	argsForCall := fake.deleteImageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteImageReturns(result1 lxd.Operation, result2 error) {
	fake.deleteImageMutex.Lock()
	defer fake.deleteImageMutex.Unlock()
	fake.DeleteImageStub = nil
	fake.deleteImageReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteImageReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteImageMutex.Lock()
	defer fake.deleteImageMutex.Unlock()
	fake.DeleteImageStub = nil
	if fake.deleteImageReturnsOnCall == nil {
		fake.deleteImageReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteImageReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteImageAlias(arg1 string) error {
	fake.deleteImageAliasMutex.Lock()
	ret, specificReturn := fake.deleteImageAliasReturnsOnCall[len(fake.deleteImageAliasArgsForCall)]
	fake.deleteImageAliasArgsForCall = append(fake.deleteImageAliasArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteImageAliasStub
	fakeReturns := fake.deleteImageAliasReturns
	fake.recordInvocation("DeleteImageAlias", []interface{}{arg1})
	fake.deleteImageAliasMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteImageAliasCallCount() int {
	fake.deleteImageAliasMutex.RLock()
	defer fake.deleteImageAliasMutex.RUnlock()
	return len(fake.deleteImageAliasArgsForCall)
}

func (fake *FakeContainerServer) DeleteImageAliasCalls(stub func(string) error) {
	fake.deleteImageAliasMutex.Lock()
	defer fake.deleteImageAliasMutex.Unlock()
	fake.DeleteImageAliasStub = stub
}

func (fake *FakeContainerServer) DeleteImageAliasArgsForCall(i int) string {
	fake.deleteImageAliasMutex.RLock()
	defer fake.deleteImageAliasMutex.RUnlock()
	argsForCall := fake.deleteImageAliasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteImageAliasReturns(result1 error) {
	fake.deleteImageAliasMutex.Lock()
	defer fake.deleteImageAliasMutex.Unlock()
	fake.DeleteImageAliasStub = nil
	fake.deleteImageAliasReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteImageAliasReturnsOnCall(i int, result1 error) {
	fake.deleteImageAliasMutex.Lock()
	defer fake.deleteImageAliasMutex.Unlock()
	fake.DeleteImageAliasStub = nil
	if fake.deleteImageAliasReturnsOnCall == nil {
		fake.deleteImageAliasReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteImageAliasReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstance(arg1 string) (lxd.Operation, error) {
	fake.deleteInstanceMutex.Lock()
	ret, specificReturn := fake.deleteInstanceReturnsOnCall[len(fake.deleteInstanceArgsForCall)]
	fake.deleteInstanceArgsForCall = append(fake.deleteInstanceArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteInstanceStub
	fakeReturns := fake.deleteInstanceReturns
	fake.recordInvocation("DeleteInstance", []interface{}{arg1})
	fake.deleteInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteInstanceCallCount() int {
	fake.deleteInstanceMutex.RLock()
	defer fake.deleteInstanceMutex.RUnlock()
	return len(fake.deleteInstanceArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceCalls(stub func(string) (lxd.Operation, error)) {
	fake.deleteInstanceMutex.Lock()
	defer fake.deleteInstanceMutex.Unlock()
	fake.DeleteInstanceStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceArgsForCall(i int) string {
	fake.deleteInstanceMutex.RLock()
	defer fake.deleteInstanceMutex.RUnlock()
	argsForCall := fake.deleteInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.deleteInstanceMutex.Lock()
	defer fake.deleteInstanceMutex.Unlock()
	fake.DeleteInstanceStub = nil
	fake.deleteInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteInstanceMutex.Lock()
	defer fake.deleteInstanceMutex.Unlock()
	fake.DeleteInstanceStub = nil
	if fake.deleteInstanceReturnsOnCall == nil {
		fake.deleteInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceBackup(arg1 string, arg2 string) (lxd.Operation, error) {
	fake.deleteInstanceBackupMutex.Lock()
	ret, specificReturn := fake.deleteInstanceBackupReturnsOnCall[len(fake.deleteInstanceBackupArgsForCall)]
	fake.deleteInstanceBackupArgsForCall = append(fake.deleteInstanceBackupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteInstanceBackupStub
	fakeReturns := fake.deleteInstanceBackupReturns
	fake.recordInvocation("DeleteInstanceBackup", []interface{}{arg1, arg2})
	fake.deleteInstanceBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteInstanceBackupCallCount() int {
	fake.deleteInstanceBackupMutex.RLock()
	defer fake.deleteInstanceBackupMutex.RUnlock()
	return len(fake.deleteInstanceBackupArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceBackupCalls(stub func(string, string) (lxd.Operation, error)) {
	fake.deleteInstanceBackupMutex.Lock()
	defer fake.deleteInstanceBackupMutex.Unlock()
	fake.DeleteInstanceBackupStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceBackupArgsForCall(i int) (string, string) {
	fake.deleteInstanceBackupMutex.RLock()
	defer fake.deleteInstanceBackupMutex.RUnlock()
	argsForCall := fake.deleteInstanceBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceBackupReturns(result1 lxd.Operation, result2 error) {
	fake.deleteInstanceBackupMutex.Lock()
	defer fake.deleteInstanceBackupMutex.Unlock()
	fake.DeleteInstanceBackupStub = nil
	fake.deleteInstanceBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteInstanceBackupMutex.Lock()
	defer fake.deleteInstanceBackupMutex.Unlock()
	fake.DeleteInstanceBackupStub = nil
	if fake.deleteInstanceBackupReturnsOnCall == nil {
		fake.deleteInstanceBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteInstanceBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLog(arg1 string, arg2 *lxd.InstanceConsoleLogArgs) error {
	fake.deleteInstanceConsoleLogMutex.Lock()
	ret, specificReturn := fake.deleteInstanceConsoleLogReturnsOnCall[len(fake.deleteInstanceConsoleLogArgsForCall)]
	fake.deleteInstanceConsoleLogArgsForCall = append(fake.deleteInstanceConsoleLogArgsForCall, struct {
		arg1 string
		arg2 *lxd.InstanceConsoleLogArgs
	}{arg1, arg2})
	stub := fake.DeleteInstanceConsoleLogStub
	fakeReturns := fake.deleteInstanceConsoleLogReturns
	fake.recordInvocation("DeleteInstanceConsoleLog", []interface{}{arg1, arg2})
	fake.deleteInstanceConsoleLogMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLogCallCount() int {
	fake.deleteInstanceConsoleLogMutex.RLock()
	defer fake.deleteInstanceConsoleLogMutex.RUnlock()
	return len(fake.deleteInstanceConsoleLogArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLogCalls(stub func(string, *lxd.InstanceConsoleLogArgs) error) {
	fake.deleteInstanceConsoleLogMutex.Lock()
	defer fake.deleteInstanceConsoleLogMutex.Unlock()
	fake.DeleteInstanceConsoleLogStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLogArgsForCall(i int) (string, *lxd.InstanceConsoleLogArgs) {
	fake.deleteInstanceConsoleLogMutex.RLock()
	defer fake.deleteInstanceConsoleLogMutex.RUnlock()
	argsForCall := fake.deleteInstanceConsoleLogArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLogReturns(result1 error) {
	fake.deleteInstanceConsoleLogMutex.Lock()
	defer fake.deleteInstanceConsoleLogMutex.Unlock()
	fake.DeleteInstanceConsoleLogStub = nil
	fake.deleteInstanceConsoleLogReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceConsoleLogReturnsOnCall(i int, result1 error) {
	fake.deleteInstanceConsoleLogMutex.Lock()
	defer fake.deleteInstanceConsoleLogMutex.Unlock()
	fake.DeleteInstanceConsoleLogStub = nil
	if fake.deleteInstanceConsoleLogReturnsOnCall == nil {
		fake.deleteInstanceConsoleLogReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteInstanceConsoleLogReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceFile(arg1 string, arg2 string) error {
	fake.deleteInstanceFileMutex.Lock()
	ret, specificReturn := fake.deleteInstanceFileReturnsOnCall[len(fake.deleteInstanceFileArgsForCall)]
	fake.deleteInstanceFileArgsForCall = append(fake.deleteInstanceFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteInstanceFileStub
	fakeReturns := fake.deleteInstanceFileReturns
	fake.recordInvocation("DeleteInstanceFile", []interface{}{arg1, arg2})
	fake.deleteInstanceFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteInstanceFileCallCount() int {
	fake.deleteInstanceFileMutex.RLock()
	defer fake.deleteInstanceFileMutex.RUnlock()
	return len(fake.deleteInstanceFileArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceFileCalls(stub func(string, string) error) {
	fake.deleteInstanceFileMutex.Lock()
	defer fake.deleteInstanceFileMutex.Unlock()
	fake.DeleteInstanceFileStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceFileArgsForCall(i int) (string, string) {
	fake.deleteInstanceFileMutex.RLock()
	defer fake.deleteInstanceFileMutex.RUnlock()
	argsForCall := fake.deleteInstanceFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceFileReturns(result1 error) {
	fake.deleteInstanceFileMutex.Lock()
	defer fake.deleteInstanceFileMutex.Unlock()
	fake.DeleteInstanceFileStub = nil
	fake.deleteInstanceFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceFileReturnsOnCall(i int, result1 error) {
	fake.deleteInstanceFileMutex.Lock()
	defer fake.deleteInstanceFileMutex.Unlock()
	fake.DeleteInstanceFileStub = nil
	if fake.deleteInstanceFileReturnsOnCall == nil {
		fake.deleteInstanceFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteInstanceFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceLogfile(arg1 string, arg2 string) error {
	fake.deleteInstanceLogfileMutex.Lock()
	ret, specificReturn := fake.deleteInstanceLogfileReturnsOnCall[len(fake.deleteInstanceLogfileArgsForCall)]
	fake.deleteInstanceLogfileArgsForCall = append(fake.deleteInstanceLogfileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteInstanceLogfileStub
	fakeReturns := fake.deleteInstanceLogfileReturns
	fake.recordInvocation("DeleteInstanceLogfile", []interface{}{arg1, arg2})
	fake.deleteInstanceLogfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteInstanceLogfileCallCount() int {
	fake.deleteInstanceLogfileMutex.RLock()
	defer fake.deleteInstanceLogfileMutex.RUnlock()
	return len(fake.deleteInstanceLogfileArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceLogfileCalls(stub func(string, string) error) {
	fake.deleteInstanceLogfileMutex.Lock()
	defer fake.deleteInstanceLogfileMutex.Unlock()
	fake.DeleteInstanceLogfileStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceLogfileArgsForCall(i int) (string, string) {
	fake.deleteInstanceLogfileMutex.RLock()
	defer fake.deleteInstanceLogfileMutex.RUnlock()
	argsForCall := fake.deleteInstanceLogfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceLogfileReturns(result1 error) {
	fake.deleteInstanceLogfileMutex.Lock()
	defer fake.deleteInstanceLogfileMutex.Unlock()
	fake.DeleteInstanceLogfileStub = nil
	fake.deleteInstanceLogfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceLogfileReturnsOnCall(i int, result1 error) {
	fake.deleteInstanceLogfileMutex.Lock()
	defer fake.deleteInstanceLogfileMutex.Unlock()
	fake.DeleteInstanceLogfileStub = nil
	if fake.deleteInstanceLogfileReturnsOnCall == nil {
		fake.deleteInstanceLogfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteInstanceLogfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceSnapshot(arg1 string, arg2 string) (lxd.Operation, error) {
	fake.deleteInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.deleteInstanceSnapshotReturnsOnCall[len(fake.deleteInstanceSnapshotArgsForCall)]
	fake.deleteInstanceSnapshotArgsForCall = append(fake.deleteInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteInstanceSnapshotStub
	fakeReturns := fake.deleteInstanceSnapshotReturns
	fake.recordInvocation("DeleteInstanceSnapshot", []interface{}{arg1, arg2})
	fake.deleteInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteInstanceSnapshotCallCount() int {
	fake.deleteInstanceSnapshotMutex.RLock()
	defer fake.deleteInstanceSnapshotMutex.RUnlock()
	return len(fake.deleteInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceSnapshotCalls(stub func(string, string) (lxd.Operation, error)) {
	fake.deleteInstanceSnapshotMutex.Lock()
	defer fake.deleteInstanceSnapshotMutex.Unlock()
	fake.DeleteInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceSnapshotArgsForCall(i int) (string, string) {
	fake.deleteInstanceSnapshotMutex.RLock()
	defer fake.deleteInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.deleteInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.deleteInstanceSnapshotMutex.Lock()
	defer fake.deleteInstanceSnapshotMutex.Unlock()
	fake.DeleteInstanceSnapshotStub = nil
	fake.deleteInstanceSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteInstanceSnapshotMutex.Lock()
	defer fake.deleteInstanceSnapshotMutex.Unlock()
	fake.DeleteInstanceSnapshotStub = nil
	if fake.deleteInstanceSnapshotReturnsOnCall == nil {
		fake.deleteInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFile(arg1 string, arg2 string) error {
	fake.deleteInstanceTemplateFileMutex.Lock()
	ret, specificReturn := fake.deleteInstanceTemplateFileReturnsOnCall[len(fake.deleteInstanceTemplateFileArgsForCall)]
	fake.deleteInstanceTemplateFileArgsForCall = append(fake.deleteInstanceTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteInstanceTemplateFileStub
	fakeReturns := fake.deleteInstanceTemplateFileReturns
	fake.recordInvocation("DeleteInstanceTemplateFile", []interface{}{arg1, arg2})
	fake.deleteInstanceTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFileCallCount() int {
	fake.deleteInstanceTemplateFileMutex.RLock()
	defer fake.deleteInstanceTemplateFileMutex.RUnlock()
	return len(fake.deleteInstanceTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFileCalls(stub func(string, string) error) {
	fake.deleteInstanceTemplateFileMutex.Lock()
	defer fake.deleteInstanceTemplateFileMutex.Unlock()
	fake.DeleteInstanceTemplateFileStub = stub
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFileArgsForCall(i int) (string, string) {
	fake.deleteInstanceTemplateFileMutex.RLock()
	defer fake.deleteInstanceTemplateFileMutex.RUnlock()
	argsForCall := fake.deleteInstanceTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFileReturns(result1 error) {
	fake.deleteInstanceTemplateFileMutex.Lock()
	defer fake.deleteInstanceTemplateFileMutex.Unlock()
	fake.DeleteInstanceTemplateFileStub = nil
	fake.deleteInstanceTemplateFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteInstanceTemplateFileReturnsOnCall(i int, result1 error) {
	fake.deleteInstanceTemplateFileMutex.Lock()
	defer fake.deleteInstanceTemplateFileMutex.Unlock()
	fake.DeleteInstanceTemplateFileStub = nil
	if fake.deleteInstanceTemplateFileReturnsOnCall == nil {
		fake.deleteInstanceTemplateFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteInstanceTemplateFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetwork(arg1 string) error {
	fake.deleteNetworkMutex.Lock()
	ret, specificReturn := fake.deleteNetworkReturnsOnCall[len(fake.deleteNetworkArgsForCall)]
	fake.deleteNetworkArgsForCall = append(fake.deleteNetworkArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteNetworkStub
	fakeReturns := fake.deleteNetworkReturns
	fake.recordInvocation("DeleteNetwork", []interface{}{arg1})
	fake.deleteNetworkMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkCallCount() int {
	fake.deleteNetworkMutex.RLock()
	defer fake.deleteNetworkMutex.RUnlock()
	return len(fake.deleteNetworkArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkCalls(stub func(string) error) {
	fake.deleteNetworkMutex.Lock()
	defer fake.deleteNetworkMutex.Unlock()
	fake.DeleteNetworkStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkArgsForCall(i int) string {
	fake.deleteNetworkMutex.RLock()
	defer fake.deleteNetworkMutex.RUnlock()
	argsForCall := fake.deleteNetworkArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteNetworkReturns(result1 error) {
	fake.deleteNetworkMutex.Lock()
	defer fake.deleteNetworkMutex.Unlock()
	fake.DeleteNetworkStub = nil
	fake.deleteNetworkReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkMutex.Lock()
	defer fake.deleteNetworkMutex.Unlock()
	fake.DeleteNetworkStub = nil
	if fake.deleteNetworkReturnsOnCall == nil {
		fake.deleteNetworkReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkACL(arg1 string) error {
	fake.deleteNetworkACLMutex.Lock()
	ret, specificReturn := fake.deleteNetworkACLReturnsOnCall[len(fake.deleteNetworkACLArgsForCall)]
	fake.deleteNetworkACLArgsForCall = append(fake.deleteNetworkACLArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteNetworkACLStub
	fakeReturns := fake.deleteNetworkACLReturns
	fake.recordInvocation("DeleteNetworkACL", []interface{}{arg1})
	fake.deleteNetworkACLMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkACLCallCount() int {
	fake.deleteNetworkACLMutex.RLock()
	defer fake.deleteNetworkACLMutex.RUnlock()
	return len(fake.deleteNetworkACLArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkACLCalls(stub func(string) error) {
	fake.deleteNetworkACLMutex.Lock()
	defer fake.deleteNetworkACLMutex.Unlock()
	fake.DeleteNetworkACLStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkACLArgsForCall(i int) string {
	fake.deleteNetworkACLMutex.RLock()
	defer fake.deleteNetworkACLMutex.RUnlock()
	argsForCall := fake.deleteNetworkACLArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteNetworkACLReturns(result1 error) {
	fake.deleteNetworkACLMutex.Lock()
	defer fake.deleteNetworkACLMutex.Unlock()
	fake.DeleteNetworkACLStub = nil
	fake.deleteNetworkACLReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkACLReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkACLMutex.Lock()
	defer fake.deleteNetworkACLMutex.Unlock()
	fake.DeleteNetworkACLStub = nil
	if fake.deleteNetworkACLReturnsOnCall == nil {
		fake.deleteNetworkACLReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkACLReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkForward(arg1 string, arg2 string) error {
	fake.deleteNetworkForwardMutex.Lock()
	ret, specificReturn := fake.deleteNetworkForwardReturnsOnCall[len(fake.deleteNetworkForwardArgsForCall)]
	fake.deleteNetworkForwardArgsForCall = append(fake.deleteNetworkForwardArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteNetworkForwardStub
	fakeReturns := fake.deleteNetworkForwardReturns
	fake.recordInvocation("DeleteNetworkForward", []interface{}{arg1, arg2})
	fake.deleteNetworkForwardMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkForwardCallCount() int {
	fake.deleteNetworkForwardMutex.RLock()
	defer fake.deleteNetworkForwardMutex.RUnlock()
	return len(fake.deleteNetworkForwardArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkForwardCalls(stub func(string, string) error) {
	fake.deleteNetworkForwardMutex.Lock()
	defer fake.deleteNetworkForwardMutex.Unlock()
	fake.DeleteNetworkForwardStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkForwardArgsForCall(i int) (string, string) {
	fake.deleteNetworkForwardMutex.RLock()
	defer fake.deleteNetworkForwardMutex.RUnlock()
	argsForCall := fake.deleteNetworkForwardArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteNetworkForwardReturns(result1 error) {
	fake.deleteNetworkForwardMutex.Lock()
	defer fake.deleteNetworkForwardMutex.Unlock()
	fake.DeleteNetworkForwardStub = nil
	fake.deleteNetworkForwardReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkForwardReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkForwardMutex.Lock()
	defer fake.deleteNetworkForwardMutex.Unlock()
	fake.DeleteNetworkForwardStub = nil
	if fake.deleteNetworkForwardReturnsOnCall == nil {
		fake.deleteNetworkForwardReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkForwardReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancer(arg1 string, arg2 string) error {
	fake.deleteNetworkLoadBalancerMutex.Lock()
	ret, specificReturn := fake.deleteNetworkLoadBalancerReturnsOnCall[len(fake.deleteNetworkLoadBalancerArgsForCall)]
	fake.deleteNetworkLoadBalancerArgsForCall = append(fake.deleteNetworkLoadBalancerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteNetworkLoadBalancerStub
	fakeReturns := fake.deleteNetworkLoadBalancerReturns
	fake.recordInvocation("DeleteNetworkLoadBalancer", []interface{}{arg1, arg2})
	fake.deleteNetworkLoadBalancerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancerCallCount() int {
	fake.deleteNetworkLoadBalancerMutex.RLock()
	defer fake.deleteNetworkLoadBalancerMutex.RUnlock()
	return len(fake.deleteNetworkLoadBalancerArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancerCalls(stub func(string, string) error) {
	fake.deleteNetworkLoadBalancerMutex.Lock()
	defer fake.deleteNetworkLoadBalancerMutex.Unlock()
	fake.DeleteNetworkLoadBalancerStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancerArgsForCall(i int) (string, string) {
	fake.deleteNetworkLoadBalancerMutex.RLock()
	defer fake.deleteNetworkLoadBalancerMutex.RUnlock()
	argsForCall := fake.deleteNetworkLoadBalancerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancerReturns(result1 error) {
	fake.deleteNetworkLoadBalancerMutex.Lock()
	defer fake.deleteNetworkLoadBalancerMutex.Unlock()
	fake.DeleteNetworkLoadBalancerStub = nil
	fake.deleteNetworkLoadBalancerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkLoadBalancerReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkLoadBalancerMutex.Lock()
	defer fake.deleteNetworkLoadBalancerMutex.Unlock()
	fake.DeleteNetworkLoadBalancerStub = nil
	if fake.deleteNetworkLoadBalancerReturnsOnCall == nil {
		fake.deleteNetworkLoadBalancerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkLoadBalancerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkPeer(arg1 string, arg2 string) error {
	fake.deleteNetworkPeerMutex.Lock()
	ret, specificReturn := fake.deleteNetworkPeerReturnsOnCall[len(fake.deleteNetworkPeerArgsForCall)]
	fake.deleteNetworkPeerArgsForCall = append(fake.deleteNetworkPeerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteNetworkPeerStub
	fakeReturns := fake.deleteNetworkPeerReturns
	fake.recordInvocation("DeleteNetworkPeer", []interface{}{arg1, arg2})
	fake.deleteNetworkPeerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkPeerCallCount() int {
	fake.deleteNetworkPeerMutex.RLock()
	defer fake.deleteNetworkPeerMutex.RUnlock()
	return len(fake.deleteNetworkPeerArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkPeerCalls(stub func(string, string) error) {
	fake.deleteNetworkPeerMutex.Lock()
	defer fake.deleteNetworkPeerMutex.Unlock()
	fake.DeleteNetworkPeerStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkPeerArgsForCall(i int) (string, string) {
	fake.deleteNetworkPeerMutex.RLock()
	defer fake.deleteNetworkPeerMutex.RUnlock()
	argsForCall := fake.deleteNetworkPeerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteNetworkPeerReturns(result1 error) {
	fake.deleteNetworkPeerMutex.Lock()
	defer fake.deleteNetworkPeerMutex.Unlock()
	fake.DeleteNetworkPeerStub = nil
	fake.deleteNetworkPeerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkPeerReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkPeerMutex.Lock()
	defer fake.deleteNetworkPeerMutex.Unlock()
	fake.DeleteNetworkPeerStub = nil
	if fake.deleteNetworkPeerReturnsOnCall == nil {
		fake.deleteNetworkPeerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkPeerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkZone(arg1 string) error {
	fake.deleteNetworkZoneMutex.Lock()
	ret, specificReturn := fake.deleteNetworkZoneReturnsOnCall[len(fake.deleteNetworkZoneArgsForCall)]
	fake.deleteNetworkZoneArgsForCall = append(fake.deleteNetworkZoneArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteNetworkZoneStub
	fakeReturns := fake.deleteNetworkZoneReturns
	fake.recordInvocation("DeleteNetworkZone", []interface{}{arg1})
	fake.deleteNetworkZoneMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkZoneCallCount() int {
	fake.deleteNetworkZoneMutex.RLock()
	defer fake.deleteNetworkZoneMutex.RUnlock()
	return len(fake.deleteNetworkZoneArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkZoneCalls(stub func(string) error) {
	fake.deleteNetworkZoneMutex.Lock()
	defer fake.deleteNetworkZoneMutex.Unlock()
	fake.DeleteNetworkZoneStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkZoneArgsForCall(i int) string {
	fake.deleteNetworkZoneMutex.RLock()
	defer fake.deleteNetworkZoneMutex.RUnlock()
	argsForCall := fake.deleteNetworkZoneArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteNetworkZoneReturns(result1 error) {
	fake.deleteNetworkZoneMutex.Lock()
	defer fake.deleteNetworkZoneMutex.Unlock()
	fake.DeleteNetworkZoneStub = nil
	fake.deleteNetworkZoneReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkZoneReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkZoneMutex.Lock()
	defer fake.deleteNetworkZoneMutex.Unlock()
	fake.DeleteNetworkZoneStub = nil
	if fake.deleteNetworkZoneReturnsOnCall == nil {
		fake.deleteNetworkZoneReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkZoneReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecord(arg1 string, arg2 string) error {
	fake.deleteNetworkZoneRecordMutex.Lock()
	ret, specificReturn := fake.deleteNetworkZoneRecordReturnsOnCall[len(fake.deleteNetworkZoneRecordArgsForCall)]
	fake.deleteNetworkZoneRecordArgsForCall = append(fake.deleteNetworkZoneRecordArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteNetworkZoneRecordStub
	fakeReturns := fake.deleteNetworkZoneRecordReturns
	fake.recordInvocation("DeleteNetworkZoneRecord", []interface{}{arg1, arg2})
	fake.deleteNetworkZoneRecordMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecordCallCount() int {
	fake.deleteNetworkZoneRecordMutex.RLock()
	defer fake.deleteNetworkZoneRecordMutex.RUnlock()
	return len(fake.deleteNetworkZoneRecordArgsForCall)
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecordCalls(stub func(string, string) error) {
	fake.deleteNetworkZoneRecordMutex.Lock()
	defer fake.deleteNetworkZoneRecordMutex.Unlock()
	fake.DeleteNetworkZoneRecordStub = stub
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecordArgsForCall(i int) (string, string) {
	fake.deleteNetworkZoneRecordMutex.RLock()
	defer fake.deleteNetworkZoneRecordMutex.RUnlock()
	argsForCall := fake.deleteNetworkZoneRecordArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecordReturns(result1 error) {
	fake.deleteNetworkZoneRecordMutex.Lock()
	defer fake.deleteNetworkZoneRecordMutex.Unlock()
	fake.DeleteNetworkZoneRecordStub = nil
	fake.deleteNetworkZoneRecordReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteNetworkZoneRecordReturnsOnCall(i int, result1 error) {
	fake.deleteNetworkZoneRecordMutex.Lock()
	defer fake.deleteNetworkZoneRecordMutex.Unlock()
	fake.DeleteNetworkZoneRecordStub = nil
	if fake.deleteNetworkZoneRecordReturnsOnCall == nil {
		fake.deleteNetworkZoneRecordReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteNetworkZoneRecordReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteOperation(arg1 string) error {
	fake.deleteOperationMutex.Lock()
	ret, specificReturn := fake.deleteOperationReturnsOnCall[len(fake.deleteOperationArgsForCall)]
	fake.deleteOperationArgsForCall = append(fake.deleteOperationArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteOperationStub
	fakeReturns := fake.deleteOperationReturns
	fake.recordInvocation("DeleteOperation", []interface{}{arg1})
	fake.deleteOperationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteOperationCallCount() int {
	fake.deleteOperationMutex.RLock()
	defer fake.deleteOperationMutex.RUnlock()
	return len(fake.deleteOperationArgsForCall)
}

func (fake *FakeContainerServer) DeleteOperationCalls(stub func(string) error) {
	fake.deleteOperationMutex.Lock()
	defer fake.deleteOperationMutex.Unlock()
	fake.DeleteOperationStub = stub
}

func (fake *FakeContainerServer) DeleteOperationArgsForCall(i int) string {
	fake.deleteOperationMutex.RLock()
	defer fake.deleteOperationMutex.RUnlock()
	argsForCall := fake.deleteOperationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteOperationReturns(result1 error) {
	fake.deleteOperationMutex.Lock()
	defer fake.deleteOperationMutex.Unlock()
	fake.DeleteOperationStub = nil
	fake.deleteOperationReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteOperationReturnsOnCall(i int, result1 error) {
	fake.deleteOperationMutex.Lock()
	defer fake.deleteOperationMutex.Unlock()
	fake.DeleteOperationStub = nil
	if fake.deleteOperationReturnsOnCall == nil {
		fake.deleteOperationReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteOperationReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteProfile(arg1 string) error {
	fake.deleteProfileMutex.Lock()
	ret, specificReturn := fake.deleteProfileReturnsOnCall[len(fake.deleteProfileArgsForCall)]
	fake.deleteProfileArgsForCall = append(fake.deleteProfileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteProfileStub
	fakeReturns := fake.deleteProfileReturns
	fake.recordInvocation("DeleteProfile", []interface{}{arg1})
	fake.deleteProfileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteProfileCallCount() int {
	fake.deleteProfileMutex.RLock()
	defer fake.deleteProfileMutex.RUnlock()
	return len(fake.deleteProfileArgsForCall)
}

func (fake *FakeContainerServer) DeleteProfileCalls(stub func(string) error) {
	fake.deleteProfileMutex.Lock()
	defer fake.deleteProfileMutex.Unlock()
	fake.DeleteProfileStub = stub
}

func (fake *FakeContainerServer) DeleteProfileArgsForCall(i int) string {
	fake.deleteProfileMutex.RLock()
	defer fake.deleteProfileMutex.RUnlock()
	argsForCall := fake.deleteProfileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteProfileReturns(result1 error) {
	fake.deleteProfileMutex.Lock()
	defer fake.deleteProfileMutex.Unlock()
	fake.DeleteProfileStub = nil
	fake.deleteProfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteProfileReturnsOnCall(i int, result1 error) {
	fake.deleteProfileMutex.Lock()
	defer fake.deleteProfileMutex.Unlock()
	fake.DeleteProfileStub = nil
	if fake.deleteProfileReturnsOnCall == nil {
		fake.deleteProfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteProfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteProject(arg1 string) error {
	fake.deleteProjectMutex.Lock()
	ret, specificReturn := fake.deleteProjectReturnsOnCall[len(fake.deleteProjectArgsForCall)]
	fake.deleteProjectArgsForCall = append(fake.deleteProjectArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteProjectStub
	fakeReturns := fake.deleteProjectReturns
	fake.recordInvocation("DeleteProject", []interface{}{arg1})
	fake.deleteProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteProjectCallCount() int {
	fake.deleteProjectMutex.RLock()
	defer fake.deleteProjectMutex.RUnlock()
	return len(fake.deleteProjectArgsForCall)
}

func (fake *FakeContainerServer) DeleteProjectCalls(stub func(string) error) {
	fake.deleteProjectMutex.Lock()
	defer fake.deleteProjectMutex.Unlock()
	fake.DeleteProjectStub = stub
}

func (fake *FakeContainerServer) DeleteProjectArgsForCall(i int) string {
	fake.deleteProjectMutex.RLock()
	defer fake.deleteProjectMutex.RUnlock()
	argsForCall := fake.deleteProjectArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteProjectReturns(result1 error) {
	fake.deleteProjectMutex.Lock()
	defer fake.deleteProjectMutex.Unlock()
	fake.DeleteProjectStub = nil
	fake.deleteProjectReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteProjectReturnsOnCall(i int, result1 error) {
	fake.deleteProjectMutex.Lock()
	defer fake.deleteProjectMutex.Unlock()
	fake.DeleteProjectStub = nil
	if fake.deleteProjectReturnsOnCall == nil {
		fake.deleteProjectReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteProjectReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteStoragePool(arg1 string) error {
	fake.deleteStoragePoolMutex.Lock()
	ret, specificReturn := fake.deleteStoragePoolReturnsOnCall[len(fake.deleteStoragePoolArgsForCall)]
	fake.deleteStoragePoolArgsForCall = append(fake.deleteStoragePoolArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteStoragePoolStub
	fakeReturns := fake.deleteStoragePoolReturns
	fake.recordInvocation("DeleteStoragePool", []interface{}{arg1})
	fake.deleteStoragePoolMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteStoragePoolCallCount() int {
	fake.deleteStoragePoolMutex.RLock()
	defer fake.deleteStoragePoolMutex.RUnlock()
	return len(fake.deleteStoragePoolArgsForCall)
}

func (fake *FakeContainerServer) DeleteStoragePoolCalls(stub func(string) error) {
	fake.deleteStoragePoolMutex.Lock()
	defer fake.deleteStoragePoolMutex.Unlock()
	fake.DeleteStoragePoolStub = stub
}

func (fake *FakeContainerServer) DeleteStoragePoolArgsForCall(i int) string {
	fake.deleteStoragePoolMutex.RLock()
	defer fake.deleteStoragePoolMutex.RUnlock()
	argsForCall := fake.deleteStoragePoolArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteStoragePoolReturns(result1 error) {
	fake.deleteStoragePoolMutex.Lock()
	defer fake.deleteStoragePoolMutex.Unlock()
	fake.DeleteStoragePoolStub = nil
	fake.deleteStoragePoolReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteStoragePoolReturnsOnCall(i int, result1 error) {
	fake.deleteStoragePoolMutex.Lock()
	defer fake.deleteStoragePoolMutex.Unlock()
	fake.DeleteStoragePoolStub = nil
	if fake.deleteStoragePoolReturnsOnCall == nil {
		fake.deleteStoragePoolReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteStoragePoolReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolume(arg1 string, arg2 string, arg3 string) error {
	fake.deleteStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.deleteStoragePoolVolumeReturnsOnCall[len(fake.deleteStoragePoolVolumeArgsForCall)]
	fake.deleteStoragePoolVolumeArgsForCall = append(fake.deleteStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.DeleteStoragePoolVolumeStub
	fakeReturns := fake.deleteStoragePoolVolumeReturns
	fake.recordInvocation("DeleteStoragePoolVolume", []interface{}{arg1, arg2, arg3})
	fake.deleteStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeCallCount() int {
	fake.deleteStoragePoolVolumeMutex.RLock()
	defer fake.deleteStoragePoolVolumeMutex.RUnlock()
	return len(fake.deleteStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeCalls(stub func(string, string, string) error) {
	fake.deleteStoragePoolVolumeMutex.Lock()
	defer fake.deleteStoragePoolVolumeMutex.Unlock()
	fake.DeleteStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeArgsForCall(i int) (string, string, string) {
	fake.deleteStoragePoolVolumeMutex.RLock()
	defer fake.deleteStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.deleteStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeReturns(result1 error) {
	fake.deleteStoragePoolVolumeMutex.Lock()
	defer fake.deleteStoragePoolVolumeMutex.Unlock()
	fake.DeleteStoragePoolVolumeStub = nil
	fake.deleteStoragePoolVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeReturnsOnCall(i int, result1 error) {
	fake.deleteStoragePoolVolumeMutex.Lock()
	defer fake.deleteStoragePoolVolumeMutex.Unlock()
	fake.DeleteStoragePoolVolumeStub = nil
	if fake.deleteStoragePoolVolumeReturnsOnCall == nil {
		fake.deleteStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackup(arg1 string, arg2 string, arg3 string) (lxd.Operation, error) {
	fake.deleteStoragePoolVolumeBackupMutex.Lock()
	ret, specificReturn := fake.deleteStoragePoolVolumeBackupReturnsOnCall[len(fake.deleteStoragePoolVolumeBackupArgsForCall)]
	fake.deleteStoragePoolVolumeBackupArgsForCall = append(fake.deleteStoragePoolVolumeBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.DeleteStoragePoolVolumeBackupStub
	fakeReturns := fake.deleteStoragePoolVolumeBackupReturns
	fake.recordInvocation("DeleteStoragePoolVolumeBackup", []interface{}{arg1, arg2, arg3})
	fake.deleteStoragePoolVolumeBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackupCallCount() int {
	fake.deleteStoragePoolVolumeBackupMutex.RLock()
	defer fake.deleteStoragePoolVolumeBackupMutex.RUnlock()
	return len(fake.deleteStoragePoolVolumeBackupArgsForCall)
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackupCalls(stub func(string, string, string) (lxd.Operation, error)) {
	fake.deleteStoragePoolVolumeBackupMutex.Lock()
	defer fake.deleteStoragePoolVolumeBackupMutex.Unlock()
	fake.DeleteStoragePoolVolumeBackupStub = stub
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackupArgsForCall(i int) (string, string, string) {
	fake.deleteStoragePoolVolumeBackupMutex.RLock()
	defer fake.deleteStoragePoolVolumeBackupMutex.RUnlock()
	argsForCall := fake.deleteStoragePoolVolumeBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackupReturns(result1 lxd.Operation, result2 error) {
	fake.deleteStoragePoolVolumeBackupMutex.Lock()
	defer fake.deleteStoragePoolVolumeBackupMutex.Unlock()
	fake.DeleteStoragePoolVolumeBackupStub = nil
	fake.deleteStoragePoolVolumeBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteStoragePoolVolumeBackupMutex.Lock()
	defer fake.deleteStoragePoolVolumeBackupMutex.Unlock()
	fake.DeleteStoragePoolVolumeBackupStub = nil
	if fake.deleteStoragePoolVolumeBackupReturnsOnCall == nil {
		fake.deleteStoragePoolVolumeBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteStoragePoolVolumeBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshot(arg1 string, arg2 string, arg3 string, arg4 string) (lxd.Operation, error) {
	fake.deleteStoragePoolVolumeSnapshotMutex.Lock()
	ret, specificReturn := fake.deleteStoragePoolVolumeSnapshotReturnsOnCall[len(fake.deleteStoragePoolVolumeSnapshotArgsForCall)]
	fake.deleteStoragePoolVolumeSnapshotArgsForCall = append(fake.deleteStoragePoolVolumeSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.DeleteStoragePoolVolumeSnapshotStub
	fakeReturns := fake.deleteStoragePoolVolumeSnapshotReturns
	fake.recordInvocation("DeleteStoragePoolVolumeSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.deleteStoragePoolVolumeSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshotCallCount() int {
	fake.deleteStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.RUnlock()
	return len(fake.deleteStoragePoolVolumeSnapshotArgsForCall)
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshotCalls(stub func(string, string, string, string) (lxd.Operation, error)) {
	fake.deleteStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.Unlock()
	fake.DeleteStoragePoolVolumeSnapshotStub = stub
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshotArgsForCall(i int) (string, string, string, string) {
	fake.deleteStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.RUnlock()
	argsForCall := fake.deleteStoragePoolVolumeSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.deleteStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.Unlock()
	fake.DeleteStoragePoolVolumeSnapshotStub = nil
	fake.deleteStoragePoolVolumeSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteStoragePoolVolumeSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.deleteStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.Unlock()
	fake.DeleteStoragePoolVolumeSnapshotStub = nil
	if fake.deleteStoragePoolVolumeSnapshotReturnsOnCall == nil {
		fake.deleteStoragePoolVolumeSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.deleteStoragePoolVolumeSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DeleteWarning(arg1 string) error {
	fake.deleteWarningMutex.Lock()
	ret, specificReturn := fake.deleteWarningReturnsOnCall[len(fake.deleteWarningArgsForCall)]
	fake.deleteWarningArgsForCall = append(fake.deleteWarningArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteWarningStub
	fakeReturns := fake.deleteWarningReturns
	fake.recordInvocation("DeleteWarning", []interface{}{arg1})
	fake.deleteWarningMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) DeleteWarningCallCount() int {
	fake.deleteWarningMutex.RLock()
	defer fake.deleteWarningMutex.RUnlock()
	return len(fake.deleteWarningArgsForCall)
}

func (fake *FakeContainerServer) DeleteWarningCalls(stub func(string) error) {
	fake.deleteWarningMutex.Lock()
	defer fake.deleteWarningMutex.Unlock()
	fake.DeleteWarningStub = stub
}

func (fake *FakeContainerServer) DeleteWarningArgsForCall(i int) string {
	fake.deleteWarningMutex.RLock()
	defer fake.deleteWarningMutex.RUnlock()
	argsForCall := fake.deleteWarningArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DeleteWarningReturns(result1 error) {
	fake.deleteWarningMutex.Lock()
	defer fake.deleteWarningMutex.Unlock()
	fake.DeleteWarningStub = nil
	fake.deleteWarningReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) DeleteWarningReturnsOnCall(i int, result1 error) {
	fake.deleteWarningMutex.Lock()
	defer fake.deleteWarningMutex.Unlock()
	fake.DeleteWarningStub = nil
	if fake.deleteWarningReturnsOnCall == nil {
		fake.deleteWarningReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteWarningReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) Disconnect() {
	fake.disconnectMutex.Lock()
	fake.disconnectArgsForCall = append(fake.disconnectArgsForCall, struct {
	}{})
	stub := fake.DisconnectStub
	fake.recordInvocation("Disconnect", []interface{}{})
	fake.disconnectMutex.Unlock()
	if stub != nil {
		fake.DisconnectStub()
	}
}

func (fake *FakeContainerServer) DisconnectCallCount() int {
	fake.disconnectMutex.RLock()
	defer fake.disconnectMutex.RUnlock()
	return len(fake.disconnectArgsForCall)
}

func (fake *FakeContainerServer) DisconnectCalls(stub func()) {
	fake.disconnectMutex.Lock()
	defer fake.disconnectMutex.Unlock()
	fake.DisconnectStub = stub
}

func (fake *FakeContainerServer) DoHTTP(arg1 *http.Request) (*http.Response, error) {
	fake.doHTTPMutex.Lock()
	ret, specificReturn := fake.doHTTPReturnsOnCall[len(fake.doHTTPArgsForCall)]
	fake.doHTTPArgsForCall = append(fake.doHTTPArgsForCall, struct {
		arg1 *http.Request
	}{arg1})
	stub := fake.DoHTTPStub
	fakeReturns := fake.doHTTPReturns
	fake.recordInvocation("DoHTTP", []interface{}{arg1})
	fake.doHTTPMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) DoHTTPCallCount() int {
	fake.doHTTPMutex.RLock()
	defer fake.doHTTPMutex.RUnlock()
	return len(fake.doHTTPArgsForCall)
}

func (fake *FakeContainerServer) DoHTTPCalls(stub func(*http.Request) (*http.Response, error)) {
	fake.doHTTPMutex.Lock()
	defer fake.doHTTPMutex.Unlock()
	fake.DoHTTPStub = stub
}

func (fake *FakeContainerServer) DoHTTPArgsForCall(i int) *http.Request {
	fake.doHTTPMutex.RLock()
	defer fake.doHTTPMutex.RUnlock()
	argsForCall := fake.doHTTPArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) DoHTTPReturns(result1 *http.Response, result2 error) {
	fake.doHTTPMutex.Lock()
	defer fake.doHTTPMutex.Unlock()
	fake.DoHTTPStub = nil
	fake.doHTTPReturns = struct {
		result1 *http.Response
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) DoHTTPReturnsOnCall(i int, result1 *http.Response, result2 error) {
	fake.doHTTPMutex.Lock()
	defer fake.doHTTPMutex.Unlock()
	fake.DoHTTPStub = nil
	if fake.doHTTPReturnsOnCall == nil {
		fake.doHTTPReturnsOnCall = make(map[int]struct {
			result1 *http.Response
			result2 error
		})
	}
	fake.doHTTPReturnsOnCall[i] = struct {
		result1 *http.Response
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExecContainer(arg1 string, arg2 api.ContainerExecPost, arg3 *lxd.ContainerExecArgs) (lxd.Operation, error) {
	fake.execContainerMutex.Lock()
	ret, specificReturn := fake.execContainerReturnsOnCall[len(fake.execContainerArgsForCall)]
	fake.execContainerArgsForCall = append(fake.execContainerArgsForCall, struct {
		arg1 string
		arg2 api.ContainerExecPost
		arg3 *lxd.ContainerExecArgs
	}{arg1, arg2, arg3})
	stub := fake.ExecContainerStub
	fakeReturns := fake.execContainerReturns
	fake.recordInvocation("ExecContainer", []interface{}{arg1, arg2, arg3})
	fake.execContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) ExecContainerCallCount() int {
	fake.execContainerMutex.RLock()
	defer fake.execContainerMutex.RUnlock()
	return len(fake.execContainerArgsForCall)
}

func (fake *FakeContainerServer) ExecContainerCalls(stub func(string, api.ContainerExecPost, *lxd.ContainerExecArgs) (lxd.Operation, error)) {
	fake.execContainerMutex.Lock()
	defer fake.execContainerMutex.Unlock()
	fake.ExecContainerStub = stub
}

func (fake *FakeContainerServer) ExecContainerArgsForCall(i int) (string, api.ContainerExecPost, *lxd.ContainerExecArgs) {
	fake.execContainerMutex.RLock()
	defer fake.execContainerMutex.RUnlock()
	argsForCall := fake.execContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) ExecContainerReturns(result1 lxd.Operation, result2 error) {
	fake.execContainerMutex.Lock()
	defer fake.execContainerMutex.Unlock()
	fake.ExecContainerStub = nil
	fake.execContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExecContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.execContainerMutex.Lock()
	defer fake.execContainerMutex.Unlock()
	fake.ExecContainerStub = nil
	if fake.execContainerReturnsOnCall == nil {
		fake.execContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.execContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExecInstance(arg1 string, arg2 api.InstanceExecPost, arg3 *lxd.InstanceExecArgs) (lxd.Operation, error) {
	fake.execInstanceMutex.Lock()
	ret, specificReturn := fake.execInstanceReturnsOnCall[len(fake.execInstanceArgsForCall)]
	fake.execInstanceArgsForCall = append(fake.execInstanceArgsForCall, struct {
		arg1 string
		arg2 api.InstanceExecPost
		arg3 *lxd.InstanceExecArgs
	}{arg1, arg2, arg3})
	stub := fake.ExecInstanceStub
	fakeReturns := fake.execInstanceReturns
	fake.recordInvocation("ExecInstance", []interface{}{arg1, arg2, arg3})
	fake.execInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) ExecInstanceCallCount() int {
	fake.execInstanceMutex.RLock()
	defer fake.execInstanceMutex.RUnlock()
	return len(fake.execInstanceArgsForCall)
}

func (fake *FakeContainerServer) ExecInstanceCalls(stub func(string, api.InstanceExecPost, *lxd.InstanceExecArgs) (lxd.Operation, error)) {
	fake.execInstanceMutex.Lock()
	defer fake.execInstanceMutex.Unlock()
	fake.ExecInstanceStub = stub
}

func (fake *FakeContainerServer) ExecInstanceArgsForCall(i int) (string, api.InstanceExecPost, *lxd.InstanceExecArgs) {
	fake.execInstanceMutex.RLock()
	defer fake.execInstanceMutex.RUnlock()
	argsForCall := fake.execInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) ExecInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.execInstanceMutex.Lock()
	defer fake.execInstanceMutex.Unlock()
	fake.ExecInstanceStub = nil
	fake.execInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExecInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.execInstanceMutex.Lock()
	defer fake.execInstanceMutex.Unlock()
	fake.ExecInstanceStub = nil
	if fake.execInstanceReturnsOnCall == nil {
		fake.execInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.execInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExportImage(arg1 string, arg2 api.ImageExportPost) (lxd.Operation, error) {
	fake.exportImageMutex.Lock()
	ret, specificReturn := fake.exportImageReturnsOnCall[len(fake.exportImageArgsForCall)]
	fake.exportImageArgsForCall = append(fake.exportImageArgsForCall, struct {
		arg1 string
		arg2 api.ImageExportPost
	}{arg1, arg2})
	stub := fake.ExportImageStub
	fakeReturns := fake.exportImageReturns
	fake.recordInvocation("ExportImage", []interface{}{arg1, arg2})
	fake.exportImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) ExportImageCallCount() int {
	fake.exportImageMutex.RLock()
	defer fake.exportImageMutex.RUnlock()
	return len(fake.exportImageArgsForCall)
}

func (fake *FakeContainerServer) ExportImageCalls(stub func(string, api.ImageExportPost) (lxd.Operation, error)) {
	fake.exportImageMutex.Lock()
	defer fake.exportImageMutex.Unlock()
	fake.ExportImageStub = stub
}

func (fake *FakeContainerServer) ExportImageArgsForCall(i int) (string, api.ImageExportPost) {
	fake.exportImageMutex.RLock()
	defer fake.exportImageMutex.RUnlock()
	argsForCall := fake.exportImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) ExportImageReturns(result1 lxd.Operation, result2 error) {
	fake.exportImageMutex.Lock()
	defer fake.exportImageMutex.Unlock()
	fake.ExportImageStub = nil
	fake.exportImageReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) ExportImageReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.exportImageMutex.Lock()
	defer fake.exportImageMutex.Unlock()
	fake.ExportImageStub = nil
	if fake.exportImageReturnsOnCall == nil {
		fake.exportImageReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.exportImageReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetCertificate(arg1 string) (*api.Certificate, string, error) {
	fake.getCertificateMutex.Lock()
	ret, specificReturn := fake.getCertificateReturnsOnCall[len(fake.getCertificateArgsForCall)]
	fake.getCertificateArgsForCall = append(fake.getCertificateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetCertificateStub
	fakeReturns := fake.getCertificateReturns
	fake.recordInvocation("GetCertificate", []interface{}{arg1})
	fake.getCertificateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetCertificateCallCount() int {
	fake.getCertificateMutex.RLock()
	defer fake.getCertificateMutex.RUnlock()
	return len(fake.getCertificateArgsForCall)
}

func (fake *FakeContainerServer) GetCertificateCalls(stub func(string) (*api.Certificate, string, error)) {
	fake.getCertificateMutex.Lock()
	defer fake.getCertificateMutex.Unlock()
	fake.GetCertificateStub = stub
}

func (fake *FakeContainerServer) GetCertificateArgsForCall(i int) string {
	fake.getCertificateMutex.RLock()
	defer fake.getCertificateMutex.RUnlock()
	argsForCall := fake.getCertificateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetCertificateReturns(result1 *api.Certificate, result2 string, result3 error) {
	fake.getCertificateMutex.Lock()
	defer fake.getCertificateMutex.Unlock()
	fake.GetCertificateStub = nil
	fake.getCertificateReturns = struct {
		result1 *api.Certificate
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetCertificateReturnsOnCall(i int, result1 *api.Certificate, result2 string, result3 error) {
	fake.getCertificateMutex.Lock()
	defer fake.getCertificateMutex.Unlock()
	fake.GetCertificateStub = nil
	if fake.getCertificateReturnsOnCall == nil {
		fake.getCertificateReturnsOnCall = make(map[int]struct {
			result1 *api.Certificate
			result2 string
			result3 error
		})
	}
	fake.getCertificateReturnsOnCall[i] = struct {
		result1 *api.Certificate
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetCertificateFingerprints() ([]string, error) {
	fake.getCertificateFingerprintsMutex.Lock()
	ret, specificReturn := fake.getCertificateFingerprintsReturnsOnCall[len(fake.getCertificateFingerprintsArgsForCall)]
	fake.getCertificateFingerprintsArgsForCall = append(fake.getCertificateFingerprintsArgsForCall, struct {
	}{})
	stub := fake.GetCertificateFingerprintsStub
	fakeReturns := fake.getCertificateFingerprintsReturns
	fake.recordInvocation("GetCertificateFingerprints", []interface{}{})
	fake.getCertificateFingerprintsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetCertificateFingerprintsCallCount() int {
	fake.getCertificateFingerprintsMutex.RLock()
	defer fake.getCertificateFingerprintsMutex.RUnlock()
	return len(fake.getCertificateFingerprintsArgsForCall)
}

func (fake *FakeContainerServer) GetCertificateFingerprintsCalls(stub func() ([]string, error)) {
	fake.getCertificateFingerprintsMutex.Lock()
	defer fake.getCertificateFingerprintsMutex.Unlock()
	fake.GetCertificateFingerprintsStub = stub
}

func (fake *FakeContainerServer) GetCertificateFingerprintsReturns(result1 []string, result2 error) {
	fake.getCertificateFingerprintsMutex.Lock()
	defer fake.getCertificateFingerprintsMutex.Unlock()
	fake.GetCertificateFingerprintsStub = nil
	fake.getCertificateFingerprintsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetCertificateFingerprintsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getCertificateFingerprintsMutex.Lock()
	defer fake.getCertificateFingerprintsMutex.Unlock()
	fake.GetCertificateFingerprintsStub = nil
	if fake.getCertificateFingerprintsReturnsOnCall == nil {
		fake.getCertificateFingerprintsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getCertificateFingerprintsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetCertificates() ([]api.Certificate, error) {
	fake.getCertificatesMutex.Lock()
	ret, specificReturn := fake.getCertificatesReturnsOnCall[len(fake.getCertificatesArgsForCall)]
	fake.getCertificatesArgsForCall = append(fake.getCertificatesArgsForCall, struct {
	}{})
	stub := fake.GetCertificatesStub
	fakeReturns := fake.getCertificatesReturns
	fake.recordInvocation("GetCertificates", []interface{}{})
	fake.getCertificatesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetCertificatesCallCount() int {
	fake.getCertificatesMutex.RLock()
	defer fake.getCertificatesMutex.RUnlock()
	return len(fake.getCertificatesArgsForCall)
}

func (fake *FakeContainerServer) GetCertificatesCalls(stub func() ([]api.Certificate, error)) {
	fake.getCertificatesMutex.Lock()
	defer fake.getCertificatesMutex.Unlock()
	fake.GetCertificatesStub = stub
}

func (fake *FakeContainerServer) GetCertificatesReturns(result1 []api.Certificate, result2 error) {
	fake.getCertificatesMutex.Lock()
	defer fake.getCertificatesMutex.Unlock()
	fake.GetCertificatesStub = nil
	fake.getCertificatesReturns = struct {
		result1 []api.Certificate
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetCertificatesReturnsOnCall(i int, result1 []api.Certificate, result2 error) {
	fake.getCertificatesMutex.Lock()
	defer fake.getCertificatesMutex.Unlock()
	fake.GetCertificatesStub = nil
	if fake.getCertificatesReturnsOnCall == nil {
		fake.getCertificatesReturnsOnCall = make(map[int]struct {
			result1 []api.Certificate
			result2 error
		})
	}
	fake.getCertificatesReturnsOnCall[i] = struct {
		result1 []api.Certificate
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetCluster() (*api.Cluster, string, error) {
	fake.getClusterMutex.Lock()
	ret, specificReturn := fake.getClusterReturnsOnCall[len(fake.getClusterArgsForCall)]
	fake.getClusterArgsForCall = append(fake.getClusterArgsForCall, struct {
	}{})
	stub := fake.GetClusterStub
	fakeReturns := fake.getClusterReturns
	fake.recordInvocation("GetCluster", []interface{}{})
	fake.getClusterMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetClusterCallCount() int {
	fake.getClusterMutex.RLock()
	defer fake.getClusterMutex.RUnlock()
	return len(fake.getClusterArgsForCall)
}

func (fake *FakeContainerServer) GetClusterCalls(stub func() (*api.Cluster, string, error)) {
	fake.getClusterMutex.Lock()
	defer fake.getClusterMutex.Unlock()
	fake.GetClusterStub = stub
}

func (fake *FakeContainerServer) GetClusterReturns(result1 *api.Cluster, result2 string, result3 error) {
	fake.getClusterMutex.Lock()
	defer fake.getClusterMutex.Unlock()
	fake.GetClusterStub = nil
	fake.getClusterReturns = struct {
		result1 *api.Cluster
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterReturnsOnCall(i int, result1 *api.Cluster, result2 string, result3 error) {
	fake.getClusterMutex.Lock()
	defer fake.getClusterMutex.Unlock()
	fake.GetClusterStub = nil
	if fake.getClusterReturnsOnCall == nil {
		fake.getClusterReturnsOnCall = make(map[int]struct {
			result1 *api.Cluster
			result2 string
			result3 error
		})
	}
	fake.getClusterReturnsOnCall[i] = struct {
		result1 *api.Cluster
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterGroup(arg1 string) (*api.ClusterGroup, string, error) {
	fake.getClusterGroupMutex.Lock()
	ret, specificReturn := fake.getClusterGroupReturnsOnCall[len(fake.getClusterGroupArgsForCall)]
	fake.getClusterGroupArgsForCall = append(fake.getClusterGroupArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetClusterGroupStub
	fakeReturns := fake.getClusterGroupReturns
	fake.recordInvocation("GetClusterGroup", []interface{}{arg1})
	fake.getClusterGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetClusterGroupCallCount() int {
	fake.getClusterGroupMutex.RLock()
	defer fake.getClusterGroupMutex.RUnlock()
	return len(fake.getClusterGroupArgsForCall)
}

func (fake *FakeContainerServer) GetClusterGroupCalls(stub func(string) (*api.ClusterGroup, string, error)) {
	fake.getClusterGroupMutex.Lock()
	defer fake.getClusterGroupMutex.Unlock()
	fake.GetClusterGroupStub = stub
}

func (fake *FakeContainerServer) GetClusterGroupArgsForCall(i int) string {
	fake.getClusterGroupMutex.RLock()
	defer fake.getClusterGroupMutex.RUnlock()
	argsForCall := fake.getClusterGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetClusterGroupReturns(result1 *api.ClusterGroup, result2 string, result3 error) {
	fake.getClusterGroupMutex.Lock()
	defer fake.getClusterGroupMutex.Unlock()
	fake.GetClusterGroupStub = nil
	fake.getClusterGroupReturns = struct {
		result1 *api.ClusterGroup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterGroupReturnsOnCall(i int, result1 *api.ClusterGroup, result2 string, result3 error) {
	fake.getClusterGroupMutex.Lock()
	defer fake.getClusterGroupMutex.Unlock()
	fake.GetClusterGroupStub = nil
	if fake.getClusterGroupReturnsOnCall == nil {
		fake.getClusterGroupReturnsOnCall = make(map[int]struct {
			result1 *api.ClusterGroup
			result2 string
			result3 error
		})
	}
	fake.getClusterGroupReturnsOnCall[i] = struct {
		result1 *api.ClusterGroup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterGroupNames() ([]string, error) {
	fake.getClusterGroupNamesMutex.Lock()
	ret, specificReturn := fake.getClusterGroupNamesReturnsOnCall[len(fake.getClusterGroupNamesArgsForCall)]
	fake.getClusterGroupNamesArgsForCall = append(fake.getClusterGroupNamesArgsForCall, struct {
	}{})
	stub := fake.GetClusterGroupNamesStub
	fakeReturns := fake.getClusterGroupNamesReturns
	fake.recordInvocation("GetClusterGroupNames", []interface{}{})
	fake.getClusterGroupNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetClusterGroupNamesCallCount() int {
	fake.getClusterGroupNamesMutex.RLock()
	defer fake.getClusterGroupNamesMutex.RUnlock()
	return len(fake.getClusterGroupNamesArgsForCall)
}

func (fake *FakeContainerServer) GetClusterGroupNamesCalls(stub func() ([]string, error)) {
	fake.getClusterGroupNamesMutex.Lock()
	defer fake.getClusterGroupNamesMutex.Unlock()
	fake.GetClusterGroupNamesStub = stub
}

func (fake *FakeContainerServer) GetClusterGroupNamesReturns(result1 []string, result2 error) {
	fake.getClusterGroupNamesMutex.Lock()
	defer fake.getClusterGroupNamesMutex.Unlock()
	fake.GetClusterGroupNamesStub = nil
	fake.getClusterGroupNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterGroupNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getClusterGroupNamesMutex.Lock()
	defer fake.getClusterGroupNamesMutex.Unlock()
	fake.GetClusterGroupNamesStub = nil
	if fake.getClusterGroupNamesReturnsOnCall == nil {
		fake.getClusterGroupNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getClusterGroupNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterGroups() ([]api.ClusterGroup, error) {
	fake.getClusterGroupsMutex.Lock()
	ret, specificReturn := fake.getClusterGroupsReturnsOnCall[len(fake.getClusterGroupsArgsForCall)]
	fake.getClusterGroupsArgsForCall = append(fake.getClusterGroupsArgsForCall, struct {
	}{})
	stub := fake.GetClusterGroupsStub
	fakeReturns := fake.getClusterGroupsReturns
	fake.recordInvocation("GetClusterGroups", []interface{}{})
	fake.getClusterGroupsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetClusterGroupsCallCount() int {
	fake.getClusterGroupsMutex.RLock()
	defer fake.getClusterGroupsMutex.RUnlock()
	return len(fake.getClusterGroupsArgsForCall)
}

func (fake *FakeContainerServer) GetClusterGroupsCalls(stub func() ([]api.ClusterGroup, error)) {
	fake.getClusterGroupsMutex.Lock()
	defer fake.getClusterGroupsMutex.Unlock()
	fake.GetClusterGroupsStub = stub
}

func (fake *FakeContainerServer) GetClusterGroupsReturns(result1 []api.ClusterGroup, result2 error) {
	fake.getClusterGroupsMutex.Lock()
	defer fake.getClusterGroupsMutex.Unlock()
	fake.GetClusterGroupsStub = nil
	fake.getClusterGroupsReturns = struct {
		result1 []api.ClusterGroup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterGroupsReturnsOnCall(i int, result1 []api.ClusterGroup, result2 error) {
	fake.getClusterGroupsMutex.Lock()
	defer fake.getClusterGroupsMutex.Unlock()
	fake.GetClusterGroupsStub = nil
	if fake.getClusterGroupsReturnsOnCall == nil {
		fake.getClusterGroupsReturnsOnCall = make(map[int]struct {
			result1 []api.ClusterGroup
			result2 error
		})
	}
	fake.getClusterGroupsReturnsOnCall[i] = struct {
		result1 []api.ClusterGroup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterMember(arg1 string) (*api.ClusterMember, string, error) {
	fake.getClusterMemberMutex.Lock()
	ret, specificReturn := fake.getClusterMemberReturnsOnCall[len(fake.getClusterMemberArgsForCall)]
	fake.getClusterMemberArgsForCall = append(fake.getClusterMemberArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetClusterMemberStub
	fakeReturns := fake.getClusterMemberReturns
	fake.recordInvocation("GetClusterMember", []interface{}{arg1})
	fake.getClusterMemberMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetClusterMemberCallCount() int {
	fake.getClusterMemberMutex.RLock()
	defer fake.getClusterMemberMutex.RUnlock()
	return len(fake.getClusterMemberArgsForCall)
}

func (fake *FakeContainerServer) GetClusterMemberCalls(stub func(string) (*api.ClusterMember, string, error)) {
	fake.getClusterMemberMutex.Lock()
	defer fake.getClusterMemberMutex.Unlock()
	fake.GetClusterMemberStub = stub
}

func (fake *FakeContainerServer) GetClusterMemberArgsForCall(i int) string {
	fake.getClusterMemberMutex.RLock()
	defer fake.getClusterMemberMutex.RUnlock()
	argsForCall := fake.getClusterMemberArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetClusterMemberReturns(result1 *api.ClusterMember, result2 string, result3 error) {
	fake.getClusterMemberMutex.Lock()
	defer fake.getClusterMemberMutex.Unlock()
	fake.GetClusterMemberStub = nil
	fake.getClusterMemberReturns = struct {
		result1 *api.ClusterMember
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterMemberReturnsOnCall(i int, result1 *api.ClusterMember, result2 string, result3 error) {
	fake.getClusterMemberMutex.Lock()
	defer fake.getClusterMemberMutex.Unlock()
	fake.GetClusterMemberStub = nil
	if fake.getClusterMemberReturnsOnCall == nil {
		fake.getClusterMemberReturnsOnCall = make(map[int]struct {
			result1 *api.ClusterMember
			result2 string
			result3 error
		})
	}
	fake.getClusterMemberReturnsOnCall[i] = struct {
		result1 *api.ClusterMember
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetClusterMemberNames() ([]string, error) {
	fake.getClusterMemberNamesMutex.Lock()
	ret, specificReturn := fake.getClusterMemberNamesReturnsOnCall[len(fake.getClusterMemberNamesArgsForCall)]
	fake.getClusterMemberNamesArgsForCall = append(fake.getClusterMemberNamesArgsForCall, struct {
	}{})
	stub := fake.GetClusterMemberNamesStub
	fakeReturns := fake.getClusterMemberNamesReturns
	fake.recordInvocation("GetClusterMemberNames", []interface{}{})
	fake.getClusterMemberNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetClusterMemberNamesCallCount() int {
	fake.getClusterMemberNamesMutex.RLock()
	defer fake.getClusterMemberNamesMutex.RUnlock()
	return len(fake.getClusterMemberNamesArgsForCall)
}

func (fake *FakeContainerServer) GetClusterMemberNamesCalls(stub func() ([]string, error)) {
	fake.getClusterMemberNamesMutex.Lock()
	defer fake.getClusterMemberNamesMutex.Unlock()
	fake.GetClusterMemberNamesStub = stub
}

func (fake *FakeContainerServer) GetClusterMemberNamesReturns(result1 []string, result2 error) {
	fake.getClusterMemberNamesMutex.Lock()
	defer fake.getClusterMemberNamesMutex.Unlock()
	fake.GetClusterMemberNamesStub = nil
	fake.getClusterMemberNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterMemberNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getClusterMemberNamesMutex.Lock()
	defer fake.getClusterMemberNamesMutex.Unlock()
	fake.GetClusterMemberNamesStub = nil
	if fake.getClusterMemberNamesReturnsOnCall == nil {
		fake.getClusterMemberNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getClusterMemberNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterMembers() ([]api.ClusterMember, error) {
	fake.getClusterMembersMutex.Lock()
	ret, specificReturn := fake.getClusterMembersReturnsOnCall[len(fake.getClusterMembersArgsForCall)]
	fake.getClusterMembersArgsForCall = append(fake.getClusterMembersArgsForCall, struct {
	}{})
	stub := fake.GetClusterMembersStub
	fakeReturns := fake.getClusterMembersReturns
	fake.recordInvocation("GetClusterMembers", []interface{}{})
	fake.getClusterMembersMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetClusterMembersCallCount() int {
	fake.getClusterMembersMutex.RLock()
	defer fake.getClusterMembersMutex.RUnlock()
	return len(fake.getClusterMembersArgsForCall)
}

func (fake *FakeContainerServer) GetClusterMembersCalls(stub func() ([]api.ClusterMember, error)) {
	fake.getClusterMembersMutex.Lock()
	defer fake.getClusterMembersMutex.Unlock()
	fake.GetClusterMembersStub = stub
}

func (fake *FakeContainerServer) GetClusterMembersReturns(result1 []api.ClusterMember, result2 error) {
	fake.getClusterMembersMutex.Lock()
	defer fake.getClusterMembersMutex.Unlock()
	fake.GetClusterMembersStub = nil
	fake.getClusterMembersReturns = struct {
		result1 []api.ClusterMember
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetClusterMembersReturnsOnCall(i int, result1 []api.ClusterMember, result2 error) {
	fake.getClusterMembersMutex.Lock()
	defer fake.getClusterMembersMutex.Unlock()
	fake.GetClusterMembersStub = nil
	if fake.getClusterMembersReturnsOnCall == nil {
		fake.getClusterMembersReturnsOnCall = make(map[int]struct {
			result1 []api.ClusterMember
			result2 error
		})
	}
	fake.getClusterMembersReturnsOnCall[i] = struct {
		result1 []api.ClusterMember
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetConnectionInfo() (*lxd.ConnectionInfo, error) {
	fake.getConnectionInfoMutex.Lock()
	ret, specificReturn := fake.getConnectionInfoReturnsOnCall[len(fake.getConnectionInfoArgsForCall)]
	fake.getConnectionInfoArgsForCall = append(fake.getConnectionInfoArgsForCall, struct {
	}{})
	stub := fake.GetConnectionInfoStub
	fakeReturns := fake.getConnectionInfoReturns
	fake.recordInvocation("GetConnectionInfo", []interface{}{})
	fake.getConnectionInfoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetConnectionInfoCallCount() int {
	fake.getConnectionInfoMutex.RLock()
	defer fake.getConnectionInfoMutex.RUnlock()
	return len(fake.getConnectionInfoArgsForCall)
}

func (fake *FakeContainerServer) GetConnectionInfoCalls(stub func() (*lxd.ConnectionInfo, error)) {
	fake.getConnectionInfoMutex.Lock()
	defer fake.getConnectionInfoMutex.Unlock()
	fake.GetConnectionInfoStub = stub
}

func (fake *FakeContainerServer) GetConnectionInfoReturns(result1 *lxd.ConnectionInfo, result2 error) {
	fake.getConnectionInfoMutex.Lock()
	defer fake.getConnectionInfoMutex.Unlock()
	fake.GetConnectionInfoStub = nil
	fake.getConnectionInfoReturns = struct {
		result1 *lxd.ConnectionInfo
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetConnectionInfoReturnsOnCall(i int, result1 *lxd.ConnectionInfo, result2 error) {
	fake.getConnectionInfoMutex.Lock()
	defer fake.getConnectionInfoMutex.Unlock()
	fake.GetConnectionInfoStub = nil
	if fake.getConnectionInfoReturnsOnCall == nil {
		fake.getConnectionInfoReturnsOnCall = make(map[int]struct {
			result1 *lxd.ConnectionInfo
			result2 error
		})
	}
	fake.getConnectionInfoReturnsOnCall[i] = struct {
		result1 *lxd.ConnectionInfo
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainer(arg1 string) (*api.Container, string, error) {
	fake.getContainerMutex.Lock()
	ret, specificReturn := fake.getContainerReturnsOnCall[len(fake.getContainerArgsForCall)]
	fake.getContainerArgsForCall = append(fake.getContainerArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerStub
	fakeReturns := fake.getContainerReturns
	fake.recordInvocation("GetContainer", []interface{}{arg1})
	fake.getContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerCallCount() int {
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	return len(fake.getContainerArgsForCall)
}

func (fake *FakeContainerServer) GetContainerCalls(stub func(string) (*api.Container, string, error)) {
	fake.getContainerMutex.Lock()
	defer fake.getContainerMutex.Unlock()
	fake.GetContainerStub = stub
}

func (fake *FakeContainerServer) GetContainerArgsForCall(i int) string {
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	argsForCall := fake.getContainerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerReturns(result1 *api.Container, result2 string, result3 error) {
	fake.getContainerMutex.Lock()
	defer fake.getContainerMutex.Unlock()
	fake.GetContainerStub = nil
	fake.getContainerReturns = struct {
		result1 *api.Container
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerReturnsOnCall(i int, result1 *api.Container, result2 string, result3 error) {
	fake.getContainerMutex.Lock()
	defer fake.getContainerMutex.Unlock()
	fake.GetContainerStub = nil
	if fake.getContainerReturnsOnCall == nil {
		fake.getContainerReturnsOnCall = make(map[int]struct {
			result1 *api.Container
			result2 string
			result3 error
		})
	}
	fake.getContainerReturnsOnCall[i] = struct {
		result1 *api.Container
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerBackup(arg1 string, arg2 string) (*api.ContainerBackup, string, error) {
	fake.getContainerBackupMutex.Lock()
	ret, specificReturn := fake.getContainerBackupReturnsOnCall[len(fake.getContainerBackupArgsForCall)]
	fake.getContainerBackupArgsForCall = append(fake.getContainerBackupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerBackupStub
	fakeReturns := fake.getContainerBackupReturns
	fake.recordInvocation("GetContainerBackup", []interface{}{arg1, arg2})
	fake.getContainerBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerBackupCallCount() int {
	fake.getContainerBackupMutex.RLock()
	defer fake.getContainerBackupMutex.RUnlock()
	return len(fake.getContainerBackupArgsForCall)
}

func (fake *FakeContainerServer) GetContainerBackupCalls(stub func(string, string) (*api.ContainerBackup, string, error)) {
	fake.getContainerBackupMutex.Lock()
	defer fake.getContainerBackupMutex.Unlock()
	fake.GetContainerBackupStub = stub
}

func (fake *FakeContainerServer) GetContainerBackupArgsForCall(i int) (string, string) {
	fake.getContainerBackupMutex.RLock()
	defer fake.getContainerBackupMutex.RUnlock()
	argsForCall := fake.getContainerBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerBackupReturns(result1 *api.ContainerBackup, result2 string, result3 error) {
	fake.getContainerBackupMutex.Lock()
	defer fake.getContainerBackupMutex.Unlock()
	fake.GetContainerBackupStub = nil
	fake.getContainerBackupReturns = struct {
		result1 *api.ContainerBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerBackupReturnsOnCall(i int, result1 *api.ContainerBackup, result2 string, result3 error) {
	fake.getContainerBackupMutex.Lock()
	defer fake.getContainerBackupMutex.Unlock()
	fake.GetContainerBackupStub = nil
	if fake.getContainerBackupReturnsOnCall == nil {
		fake.getContainerBackupReturnsOnCall = make(map[int]struct {
			result1 *api.ContainerBackup
			result2 string
			result3 error
		})
	}
	fake.getContainerBackupReturnsOnCall[i] = struct {
		result1 *api.ContainerBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerBackupFile(arg1 string, arg2 string, arg3 *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error) {
	fake.getContainerBackupFileMutex.Lock()
	ret, specificReturn := fake.getContainerBackupFileReturnsOnCall[len(fake.getContainerBackupFileArgsForCall)]
	fake.getContainerBackupFileArgsForCall = append(fake.getContainerBackupFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 *lxd.BackupFileRequest
	}{arg1, arg2, arg3})
	stub := fake.GetContainerBackupFileStub
	fakeReturns := fake.getContainerBackupFileReturns
	fake.recordInvocation("GetContainerBackupFile", []interface{}{arg1, arg2, arg3})
	fake.getContainerBackupFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerBackupFileCallCount() int {
	fake.getContainerBackupFileMutex.RLock()
	defer fake.getContainerBackupFileMutex.RUnlock()
	return len(fake.getContainerBackupFileArgsForCall)
}

func (fake *FakeContainerServer) GetContainerBackupFileCalls(stub func(string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)) {
	fake.getContainerBackupFileMutex.Lock()
	defer fake.getContainerBackupFileMutex.Unlock()
	fake.GetContainerBackupFileStub = stub
}

func (fake *FakeContainerServer) GetContainerBackupFileArgsForCall(i int) (string, string, *lxd.BackupFileRequest) {
	fake.getContainerBackupFileMutex.RLock()
	defer fake.getContainerBackupFileMutex.RUnlock()
	argsForCall := fake.getContainerBackupFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetContainerBackupFileReturns(result1 *lxd.BackupFileResponse, result2 error) {
	fake.getContainerBackupFileMutex.Lock()
	defer fake.getContainerBackupFileMutex.Unlock()
	fake.GetContainerBackupFileStub = nil
	fake.getContainerBackupFileReturns = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerBackupFileReturnsOnCall(i int, result1 *lxd.BackupFileResponse, result2 error) {
	fake.getContainerBackupFileMutex.Lock()
	defer fake.getContainerBackupFileMutex.Unlock()
	fake.GetContainerBackupFileStub = nil
	if fake.getContainerBackupFileReturnsOnCall == nil {
		fake.getContainerBackupFileReturnsOnCall = make(map[int]struct {
			result1 *lxd.BackupFileResponse
			result2 error
		})
	}
	fake.getContainerBackupFileReturnsOnCall[i] = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerBackupNames(arg1 string) ([]string, error) {
	fake.getContainerBackupNamesMutex.Lock()
	ret, specificReturn := fake.getContainerBackupNamesReturnsOnCall[len(fake.getContainerBackupNamesArgsForCall)]
	fake.getContainerBackupNamesArgsForCall = append(fake.getContainerBackupNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerBackupNamesStub
	fakeReturns := fake.getContainerBackupNamesReturns
	fake.recordInvocation("GetContainerBackupNames", []interface{}{arg1})
	fake.getContainerBackupNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerBackupNamesCallCount() int {
	fake.getContainerBackupNamesMutex.RLock()
	defer fake.getContainerBackupNamesMutex.RUnlock()
	return len(fake.getContainerBackupNamesArgsForCall)
}

func (fake *FakeContainerServer) GetContainerBackupNamesCalls(stub func(string) ([]string, error)) {
	fake.getContainerBackupNamesMutex.Lock()
	defer fake.getContainerBackupNamesMutex.Unlock()
	fake.GetContainerBackupNamesStub = stub
}

func (fake *FakeContainerServer) GetContainerBackupNamesArgsForCall(i int) string {
	fake.getContainerBackupNamesMutex.RLock()
	defer fake.getContainerBackupNamesMutex.RUnlock()
	argsForCall := fake.getContainerBackupNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerBackupNamesReturns(result1 []string, result2 error) {
	fake.getContainerBackupNamesMutex.Lock()
	defer fake.getContainerBackupNamesMutex.Unlock()
	fake.GetContainerBackupNamesStub = nil
	fake.getContainerBackupNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerBackupNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getContainerBackupNamesMutex.Lock()
	defer fake.getContainerBackupNamesMutex.Unlock()
	fake.GetContainerBackupNamesStub = nil
	if fake.getContainerBackupNamesReturnsOnCall == nil {
		fake.getContainerBackupNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getContainerBackupNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerBackups(arg1 string) ([]api.ContainerBackup, error) {
	fake.getContainerBackupsMutex.Lock()
	ret, specificReturn := fake.getContainerBackupsReturnsOnCall[len(fake.getContainerBackupsArgsForCall)]
	fake.getContainerBackupsArgsForCall = append(fake.getContainerBackupsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerBackupsStub
	fakeReturns := fake.getContainerBackupsReturns
	fake.recordInvocation("GetContainerBackups", []interface{}{arg1})
	fake.getContainerBackupsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerBackupsCallCount() int {
	fake.getContainerBackupsMutex.RLock()
	defer fake.getContainerBackupsMutex.RUnlock()
	return len(fake.getContainerBackupsArgsForCall)
}

func (fake *FakeContainerServer) GetContainerBackupsCalls(stub func(string) ([]api.ContainerBackup, error)) {
	fake.getContainerBackupsMutex.Lock()
	defer fake.getContainerBackupsMutex.Unlock()
	fake.GetContainerBackupsStub = stub
}

func (fake *FakeContainerServer) GetContainerBackupsArgsForCall(i int) string {
	fake.getContainerBackupsMutex.RLock()
	defer fake.getContainerBackupsMutex.RUnlock()
	argsForCall := fake.getContainerBackupsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerBackupsReturns(result1 []api.ContainerBackup, result2 error) {
	fake.getContainerBackupsMutex.Lock()
	defer fake.getContainerBackupsMutex.Unlock()
	fake.GetContainerBackupsStub = nil
	fake.getContainerBackupsReturns = struct {
		result1 []api.ContainerBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerBackupsReturnsOnCall(i int, result1 []api.ContainerBackup, result2 error) {
	fake.getContainerBackupsMutex.Lock()
	defer fake.getContainerBackupsMutex.Unlock()
	fake.GetContainerBackupsStub = nil
	if fake.getContainerBackupsReturnsOnCall == nil {
		fake.getContainerBackupsReturnsOnCall = make(map[int]struct {
			result1 []api.ContainerBackup
			result2 error
		})
	}
	fake.getContainerBackupsReturnsOnCall[i] = struct {
		result1 []api.ContainerBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerConsoleLog(arg1 string, arg2 *lxd.ContainerConsoleLogArgs) (io.ReadCloser, error) {
	fake.getContainerConsoleLogMutex.Lock()
	ret, specificReturn := fake.getContainerConsoleLogReturnsOnCall[len(fake.getContainerConsoleLogArgsForCall)]
	fake.getContainerConsoleLogArgsForCall = append(fake.getContainerConsoleLogArgsForCall, struct {
		arg1 string
		arg2 *lxd.ContainerConsoleLogArgs
	}{arg1, arg2})
	stub := fake.GetContainerConsoleLogStub
	fakeReturns := fake.getContainerConsoleLogReturns
	fake.recordInvocation("GetContainerConsoleLog", []interface{}{arg1, arg2})
	fake.getContainerConsoleLogMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerConsoleLogCallCount() int {
	fake.getContainerConsoleLogMutex.RLock()
	defer fake.getContainerConsoleLogMutex.RUnlock()
	return len(fake.getContainerConsoleLogArgsForCall)
}

func (fake *FakeContainerServer) GetContainerConsoleLogCalls(stub func(string, *lxd.ContainerConsoleLogArgs) (io.ReadCloser, error)) {
	fake.getContainerConsoleLogMutex.Lock()
	defer fake.getContainerConsoleLogMutex.Unlock()
	fake.GetContainerConsoleLogStub = stub
}

func (fake *FakeContainerServer) GetContainerConsoleLogArgsForCall(i int) (string, *lxd.ContainerConsoleLogArgs) {
	fake.getContainerConsoleLogMutex.RLock()
	defer fake.getContainerConsoleLogMutex.RUnlock()
	argsForCall := fake.getContainerConsoleLogArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerConsoleLogReturns(result1 io.ReadCloser, result2 error) {
	fake.getContainerConsoleLogMutex.Lock()
	defer fake.getContainerConsoleLogMutex.Unlock()
	fake.GetContainerConsoleLogStub = nil
	fake.getContainerConsoleLogReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerConsoleLogReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getContainerConsoleLogMutex.Lock()
	defer fake.getContainerConsoleLogMutex.Unlock()
	fake.GetContainerConsoleLogStub = nil
	if fake.getContainerConsoleLogReturnsOnCall == nil {
		fake.getContainerConsoleLogReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getContainerConsoleLogReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerFile(arg1 string, arg2 string) (io.ReadCloser, *lxd.ContainerFileResponse, error) {
	fake.getContainerFileMutex.Lock()
	ret, specificReturn := fake.getContainerFileReturnsOnCall[len(fake.getContainerFileArgsForCall)]
	fake.getContainerFileArgsForCall = append(fake.getContainerFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerFileStub
	fakeReturns := fake.getContainerFileReturns
	fake.recordInvocation("GetContainerFile", []interface{}{arg1, arg2})
	fake.getContainerFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerFileCallCount() int {
	fake.getContainerFileMutex.RLock()
	defer fake.getContainerFileMutex.RUnlock()
	return len(fake.getContainerFileArgsForCall)
}

func (fake *FakeContainerServer) GetContainerFileCalls(stub func(string, string) (io.ReadCloser, *lxd.ContainerFileResponse, error)) {
	fake.getContainerFileMutex.Lock()
	defer fake.getContainerFileMutex.Unlock()
	fake.GetContainerFileStub = stub
}

func (fake *FakeContainerServer) GetContainerFileArgsForCall(i int) (string, string) {
	fake.getContainerFileMutex.RLock()
	defer fake.getContainerFileMutex.RUnlock()
	argsForCall := fake.getContainerFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerFileReturns(result1 io.ReadCloser, result2 *lxd.ContainerFileResponse, result3 error) {
	fake.getContainerFileMutex.Lock()
	defer fake.getContainerFileMutex.Unlock()
	fake.GetContainerFileStub = nil
	fake.getContainerFileReturns = struct {
		result1 io.ReadCloser
		result2 *lxd.ContainerFileResponse
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerFileReturnsOnCall(i int, result1 io.ReadCloser, result2 *lxd.ContainerFileResponse, result3 error) {
	fake.getContainerFileMutex.Lock()
	defer fake.getContainerFileMutex.Unlock()
	fake.GetContainerFileStub = nil
	if fake.getContainerFileReturnsOnCall == nil {
		fake.getContainerFileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 *lxd.ContainerFileResponse
			result3 error
		})
	}
	fake.getContainerFileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 *lxd.ContainerFileResponse
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerLogfile(arg1 string, arg2 string) (io.ReadCloser, error) {
	fake.getContainerLogfileMutex.Lock()
	ret, specificReturn := fake.getContainerLogfileReturnsOnCall[len(fake.getContainerLogfileArgsForCall)]
	fake.getContainerLogfileArgsForCall = append(fake.getContainerLogfileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerLogfileStub
	fakeReturns := fake.getContainerLogfileReturns
	fake.recordInvocation("GetContainerLogfile", []interface{}{arg1, arg2})
	fake.getContainerLogfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerLogfileCallCount() int {
	fake.getContainerLogfileMutex.RLock()
	defer fake.getContainerLogfileMutex.RUnlock()
	return len(fake.getContainerLogfileArgsForCall)
}

func (fake *FakeContainerServer) GetContainerLogfileCalls(stub func(string, string) (io.ReadCloser, error)) {
	fake.getContainerLogfileMutex.Lock()
	defer fake.getContainerLogfileMutex.Unlock()
	fake.GetContainerLogfileStub = stub
}

func (fake *FakeContainerServer) GetContainerLogfileArgsForCall(i int) (string, string) {
	fake.getContainerLogfileMutex.RLock()
	defer fake.getContainerLogfileMutex.RUnlock()
	argsForCall := fake.getContainerLogfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerLogfileReturns(result1 io.ReadCloser, result2 error) {
	fake.getContainerLogfileMutex.Lock()
	defer fake.getContainerLogfileMutex.Unlock()
	fake.GetContainerLogfileStub = nil
	fake.getContainerLogfileReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerLogfileReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getContainerLogfileMutex.Lock()
	defer fake.getContainerLogfileMutex.Unlock()
	fake.GetContainerLogfileStub = nil
	if fake.getContainerLogfileReturnsOnCall == nil {
		fake.getContainerLogfileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getContainerLogfileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerLogfiles(arg1 string) ([]string, error) {
	fake.getContainerLogfilesMutex.Lock()
	ret, specificReturn := fake.getContainerLogfilesReturnsOnCall[len(fake.getContainerLogfilesArgsForCall)]
	fake.getContainerLogfilesArgsForCall = append(fake.getContainerLogfilesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerLogfilesStub
	fakeReturns := fake.getContainerLogfilesReturns
	fake.recordInvocation("GetContainerLogfiles", []interface{}{arg1})
	fake.getContainerLogfilesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerLogfilesCallCount() int {
	fake.getContainerLogfilesMutex.RLock()
	defer fake.getContainerLogfilesMutex.RUnlock()
	return len(fake.getContainerLogfilesArgsForCall)
}

func (fake *FakeContainerServer) GetContainerLogfilesCalls(stub func(string) ([]string, error)) {
	fake.getContainerLogfilesMutex.Lock()
	defer fake.getContainerLogfilesMutex.Unlock()
	fake.GetContainerLogfilesStub = stub
}

func (fake *FakeContainerServer) GetContainerLogfilesArgsForCall(i int) string {
	fake.getContainerLogfilesMutex.RLock()
	defer fake.getContainerLogfilesMutex.RUnlock()
	argsForCall := fake.getContainerLogfilesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerLogfilesReturns(result1 []string, result2 error) {
	fake.getContainerLogfilesMutex.Lock()
	defer fake.getContainerLogfilesMutex.Unlock()
	fake.GetContainerLogfilesStub = nil
	fake.getContainerLogfilesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerLogfilesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getContainerLogfilesMutex.Lock()
	defer fake.getContainerLogfilesMutex.Unlock()
	fake.GetContainerLogfilesStub = nil
	if fake.getContainerLogfilesReturnsOnCall == nil {
		fake.getContainerLogfilesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getContainerLogfilesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerMetadata(arg1 string) (*api.ImageMetadata, string, error) {
	fake.getContainerMetadataMutex.Lock()
	ret, specificReturn := fake.getContainerMetadataReturnsOnCall[len(fake.getContainerMetadataArgsForCall)]
	fake.getContainerMetadataArgsForCall = append(fake.getContainerMetadataArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerMetadataStub
	fakeReturns := fake.getContainerMetadataReturns
	fake.recordInvocation("GetContainerMetadata", []interface{}{arg1})
	fake.getContainerMetadataMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerMetadataCallCount() int {
	fake.getContainerMetadataMutex.RLock()
	defer fake.getContainerMetadataMutex.RUnlock()
	return len(fake.getContainerMetadataArgsForCall)
}

func (fake *FakeContainerServer) GetContainerMetadataCalls(stub func(string) (*api.ImageMetadata, string, error)) {
	fake.getContainerMetadataMutex.Lock()
	defer fake.getContainerMetadataMutex.Unlock()
	fake.GetContainerMetadataStub = stub
}

func (fake *FakeContainerServer) GetContainerMetadataArgsForCall(i int) string {
	fake.getContainerMetadataMutex.RLock()
	defer fake.getContainerMetadataMutex.RUnlock()
	argsForCall := fake.getContainerMetadataArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerMetadataReturns(result1 *api.ImageMetadata, result2 string, result3 error) {
	fake.getContainerMetadataMutex.Lock()
	defer fake.getContainerMetadataMutex.Unlock()
	fake.GetContainerMetadataStub = nil
	fake.getContainerMetadataReturns = struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerMetadataReturnsOnCall(i int, result1 *api.ImageMetadata, result2 string, result3 error) {
	fake.getContainerMetadataMutex.Lock()
	defer fake.getContainerMetadataMutex.Unlock()
	fake.GetContainerMetadataStub = nil
	if fake.getContainerMetadataReturnsOnCall == nil {
		fake.getContainerMetadataReturnsOnCall = make(map[int]struct {
			result1 *api.ImageMetadata
			result2 string
			result3 error
		})
	}
	fake.getContainerMetadataReturnsOnCall[i] = struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerNames() ([]string, error) {
	fake.getContainerNamesMutex.Lock()
	ret, specificReturn := fake.getContainerNamesReturnsOnCall[len(fake.getContainerNamesArgsForCall)]
	fake.getContainerNamesArgsForCall = append(fake.getContainerNamesArgsForCall, struct {
	}{})
	stub := fake.GetContainerNamesStub
	fakeReturns := fake.getContainerNamesReturns
	fake.recordInvocation("GetContainerNames", []interface{}{})
	fake.getContainerNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerNamesCallCount() int {
	fake.getContainerNamesMutex.RLock()
	defer fake.getContainerNamesMutex.RUnlock()
	return len(fake.getContainerNamesArgsForCall)
}

func (fake *FakeContainerServer) GetContainerNamesCalls(stub func() ([]string, error)) {
	fake.getContainerNamesMutex.Lock()
	defer fake.getContainerNamesMutex.Unlock()
	fake.GetContainerNamesStub = stub
}

func (fake *FakeContainerServer) GetContainerNamesReturns(result1 []string, result2 error) {
	fake.getContainerNamesMutex.Lock()
	defer fake.getContainerNamesMutex.Unlock()
	fake.GetContainerNamesStub = nil
	fake.getContainerNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getContainerNamesMutex.Lock()
	defer fake.getContainerNamesMutex.Unlock()
	fake.GetContainerNamesStub = nil
	if fake.getContainerNamesReturnsOnCall == nil {
		fake.getContainerNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getContainerNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerSnapshot(arg1 string, arg2 string) (*api.ContainerSnapshot, string, error) {
	fake.getContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.getContainerSnapshotReturnsOnCall[len(fake.getContainerSnapshotArgsForCall)]
	fake.getContainerSnapshotArgsForCall = append(fake.getContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerSnapshotStub
	fakeReturns := fake.getContainerSnapshotReturns
	fake.recordInvocation("GetContainerSnapshot", []interface{}{arg1, arg2})
	fake.getContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerSnapshotCallCount() int {
	fake.getContainerSnapshotMutex.RLock()
	defer fake.getContainerSnapshotMutex.RUnlock()
	return len(fake.getContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) GetContainerSnapshotCalls(stub func(string, string) (*api.ContainerSnapshot, string, error)) {
	fake.getContainerSnapshotMutex.Lock()
	defer fake.getContainerSnapshotMutex.Unlock()
	fake.GetContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) GetContainerSnapshotArgsForCall(i int) (string, string) {
	fake.getContainerSnapshotMutex.RLock()
	defer fake.getContainerSnapshotMutex.RUnlock()
	argsForCall := fake.getContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerSnapshotReturns(result1 *api.ContainerSnapshot, result2 string, result3 error) {
	fake.getContainerSnapshotMutex.Lock()
	defer fake.getContainerSnapshotMutex.Unlock()
	fake.GetContainerSnapshotStub = nil
	fake.getContainerSnapshotReturns = struct {
		result1 *api.ContainerSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerSnapshotReturnsOnCall(i int, result1 *api.ContainerSnapshot, result2 string, result3 error) {
	fake.getContainerSnapshotMutex.Lock()
	defer fake.getContainerSnapshotMutex.Unlock()
	fake.GetContainerSnapshotStub = nil
	if fake.getContainerSnapshotReturnsOnCall == nil {
		fake.getContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 *api.ContainerSnapshot
			result2 string
			result3 error
		})
	}
	fake.getContainerSnapshotReturnsOnCall[i] = struct {
		result1 *api.ContainerSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerSnapshotNames(arg1 string) ([]string, error) {
	fake.getContainerSnapshotNamesMutex.Lock()
	ret, specificReturn := fake.getContainerSnapshotNamesReturnsOnCall[len(fake.getContainerSnapshotNamesArgsForCall)]
	fake.getContainerSnapshotNamesArgsForCall = append(fake.getContainerSnapshotNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerSnapshotNamesStub
	fakeReturns := fake.getContainerSnapshotNamesReturns
	fake.recordInvocation("GetContainerSnapshotNames", []interface{}{arg1})
	fake.getContainerSnapshotNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerSnapshotNamesCallCount() int {
	fake.getContainerSnapshotNamesMutex.RLock()
	defer fake.getContainerSnapshotNamesMutex.RUnlock()
	return len(fake.getContainerSnapshotNamesArgsForCall)
}

func (fake *FakeContainerServer) GetContainerSnapshotNamesCalls(stub func(string) ([]string, error)) {
	fake.getContainerSnapshotNamesMutex.Lock()
	defer fake.getContainerSnapshotNamesMutex.Unlock()
	fake.GetContainerSnapshotNamesStub = stub
}

func (fake *FakeContainerServer) GetContainerSnapshotNamesArgsForCall(i int) string {
	fake.getContainerSnapshotNamesMutex.RLock()
	defer fake.getContainerSnapshotNamesMutex.RUnlock()
	argsForCall := fake.getContainerSnapshotNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerSnapshotNamesReturns(result1 []string, result2 error) {
	fake.getContainerSnapshotNamesMutex.Lock()
	defer fake.getContainerSnapshotNamesMutex.Unlock()
	fake.GetContainerSnapshotNamesStub = nil
	fake.getContainerSnapshotNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerSnapshotNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getContainerSnapshotNamesMutex.Lock()
	defer fake.getContainerSnapshotNamesMutex.Unlock()
	fake.GetContainerSnapshotNamesStub = nil
	if fake.getContainerSnapshotNamesReturnsOnCall == nil {
		fake.getContainerSnapshotNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getContainerSnapshotNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerSnapshots(arg1 string) ([]api.ContainerSnapshot, error) {
	fake.getContainerSnapshotsMutex.Lock()
	ret, specificReturn := fake.getContainerSnapshotsReturnsOnCall[len(fake.getContainerSnapshotsArgsForCall)]
	fake.getContainerSnapshotsArgsForCall = append(fake.getContainerSnapshotsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerSnapshotsStub
	fakeReturns := fake.getContainerSnapshotsReturns
	fake.recordInvocation("GetContainerSnapshots", []interface{}{arg1})
	fake.getContainerSnapshotsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerSnapshotsCallCount() int {
	fake.getContainerSnapshotsMutex.RLock()
	defer fake.getContainerSnapshotsMutex.RUnlock()
	return len(fake.getContainerSnapshotsArgsForCall)
}

func (fake *FakeContainerServer) GetContainerSnapshotsCalls(stub func(string) ([]api.ContainerSnapshot, error)) {
	fake.getContainerSnapshotsMutex.Lock()
	defer fake.getContainerSnapshotsMutex.Unlock()
	fake.GetContainerSnapshotsStub = stub
}

func (fake *FakeContainerServer) GetContainerSnapshotsArgsForCall(i int) string {
	fake.getContainerSnapshotsMutex.RLock()
	defer fake.getContainerSnapshotsMutex.RUnlock()
	argsForCall := fake.getContainerSnapshotsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerSnapshotsReturns(result1 []api.ContainerSnapshot, result2 error) {
	fake.getContainerSnapshotsMutex.Lock()
	defer fake.getContainerSnapshotsMutex.Unlock()
	fake.GetContainerSnapshotsStub = nil
	fake.getContainerSnapshotsReturns = struct {
		result1 []api.ContainerSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerSnapshotsReturnsOnCall(i int, result1 []api.ContainerSnapshot, result2 error) {
	fake.getContainerSnapshotsMutex.Lock()
	defer fake.getContainerSnapshotsMutex.Unlock()
	fake.GetContainerSnapshotsStub = nil
	if fake.getContainerSnapshotsReturnsOnCall == nil {
		fake.getContainerSnapshotsReturnsOnCall = make(map[int]struct {
			result1 []api.ContainerSnapshot
			result2 error
		})
	}
	fake.getContainerSnapshotsReturnsOnCall[i] = struct {
		result1 []api.ContainerSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerState(arg1 string) (*api.ContainerState, string, error) {
	fake.getContainerStateMutex.Lock()
	ret, specificReturn := fake.getContainerStateReturnsOnCall[len(fake.getContainerStateArgsForCall)]
	fake.getContainerStateArgsForCall = append(fake.getContainerStateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerStateStub
	fakeReturns := fake.getContainerStateReturns
	fake.recordInvocation("GetContainerState", []interface{}{arg1})
	fake.getContainerStateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetContainerStateCallCount() int {
	fake.getContainerStateMutex.RLock()
	defer fake.getContainerStateMutex.RUnlock()
	return len(fake.getContainerStateArgsForCall)
}

func (fake *FakeContainerServer) GetContainerStateCalls(stub func(string) (*api.ContainerState, string, error)) {
	fake.getContainerStateMutex.Lock()
	defer fake.getContainerStateMutex.Unlock()
	fake.GetContainerStateStub = stub
}

func (fake *FakeContainerServer) GetContainerStateArgsForCall(i int) string {
	fake.getContainerStateMutex.RLock()
	defer fake.getContainerStateMutex.RUnlock()
	argsForCall := fake.getContainerStateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerStateReturns(result1 *api.ContainerState, result2 string, result3 error) {
	fake.getContainerStateMutex.Lock()
	defer fake.getContainerStateMutex.Unlock()
	fake.GetContainerStateStub = nil
	fake.getContainerStateReturns = struct {
		result1 *api.ContainerState
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerStateReturnsOnCall(i int, result1 *api.ContainerState, result2 string, result3 error) {
	fake.getContainerStateMutex.Lock()
	defer fake.getContainerStateMutex.Unlock()
	fake.GetContainerStateStub = nil
	if fake.getContainerStateReturnsOnCall == nil {
		fake.getContainerStateReturnsOnCall = make(map[int]struct {
			result1 *api.ContainerState
			result2 string
			result3 error
		})
	}
	fake.getContainerStateReturnsOnCall[i] = struct {
		result1 *api.ContainerState
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetContainerTemplateFile(arg1 string, arg2 string) (io.ReadCloser, error) {
	fake.getContainerTemplateFileMutex.Lock()
	ret, specificReturn := fake.getContainerTemplateFileReturnsOnCall[len(fake.getContainerTemplateFileArgsForCall)]
	fake.getContainerTemplateFileArgsForCall = append(fake.getContainerTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerTemplateFileStub
	fakeReturns := fake.getContainerTemplateFileReturns
	fake.recordInvocation("GetContainerTemplateFile", []interface{}{arg1, arg2})
	fake.getContainerTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerTemplateFileCallCount() int {
	fake.getContainerTemplateFileMutex.RLock()
	defer fake.getContainerTemplateFileMutex.RUnlock()
	return len(fake.getContainerTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) GetContainerTemplateFileCalls(stub func(string, string) (io.ReadCloser, error)) {
	fake.getContainerTemplateFileMutex.Lock()
	defer fake.getContainerTemplateFileMutex.Unlock()
	fake.GetContainerTemplateFileStub = stub
}

func (fake *FakeContainerServer) GetContainerTemplateFileArgsForCall(i int) (string, string) {
	fake.getContainerTemplateFileMutex.RLock()
	defer fake.getContainerTemplateFileMutex.RUnlock()
	argsForCall := fake.getContainerTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetContainerTemplateFileReturns(result1 io.ReadCloser, result2 error) {
	fake.getContainerTemplateFileMutex.Lock()
	defer fake.getContainerTemplateFileMutex.Unlock()
	fake.GetContainerTemplateFileStub = nil
	fake.getContainerTemplateFileReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerTemplateFileReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getContainerTemplateFileMutex.Lock()
	defer fake.getContainerTemplateFileMutex.Unlock()
	fake.GetContainerTemplateFileStub = nil
	if fake.getContainerTemplateFileReturnsOnCall == nil {
		fake.getContainerTemplateFileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getContainerTemplateFileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerTemplateFiles(arg1 string) ([]string, error) {
	fake.getContainerTemplateFilesMutex.Lock()
	ret, specificReturn := fake.getContainerTemplateFilesReturnsOnCall[len(fake.getContainerTemplateFilesArgsForCall)]
	fake.getContainerTemplateFilesArgsForCall = append(fake.getContainerTemplateFilesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetContainerTemplateFilesStub
	fakeReturns := fake.getContainerTemplateFilesReturns
	fake.recordInvocation("GetContainerTemplateFiles", []interface{}{arg1})
	fake.getContainerTemplateFilesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainerTemplateFilesCallCount() int {
	fake.getContainerTemplateFilesMutex.RLock()
	defer fake.getContainerTemplateFilesMutex.RUnlock()
	return len(fake.getContainerTemplateFilesArgsForCall)
}

func (fake *FakeContainerServer) GetContainerTemplateFilesCalls(stub func(string) ([]string, error)) {
	fake.getContainerTemplateFilesMutex.Lock()
	defer fake.getContainerTemplateFilesMutex.Unlock()
	fake.GetContainerTemplateFilesStub = stub
}

func (fake *FakeContainerServer) GetContainerTemplateFilesArgsForCall(i int) string {
	fake.getContainerTemplateFilesMutex.RLock()
	defer fake.getContainerTemplateFilesMutex.RUnlock()
	argsForCall := fake.getContainerTemplateFilesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetContainerTemplateFilesReturns(result1 []string, result2 error) {
	fake.getContainerTemplateFilesMutex.Lock()
	defer fake.getContainerTemplateFilesMutex.Unlock()
	fake.GetContainerTemplateFilesStub = nil
	fake.getContainerTemplateFilesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainerTemplateFilesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getContainerTemplateFilesMutex.Lock()
	defer fake.getContainerTemplateFilesMutex.Unlock()
	fake.GetContainerTemplateFilesStub = nil
	if fake.getContainerTemplateFilesReturnsOnCall == nil {
		fake.getContainerTemplateFilesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getContainerTemplateFilesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainers() ([]api.Container, error) {
	fake.getContainersMutex.Lock()
	ret, specificReturn := fake.getContainersReturnsOnCall[len(fake.getContainersArgsForCall)]
	fake.getContainersArgsForCall = append(fake.getContainersArgsForCall, struct {
	}{})
	stub := fake.GetContainersStub
	fakeReturns := fake.getContainersReturns
	fake.recordInvocation("GetContainers", []interface{}{})
	fake.getContainersMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainersCallCount() int {
	fake.getContainersMutex.RLock()
	defer fake.getContainersMutex.RUnlock()
	return len(fake.getContainersArgsForCall)
}

func (fake *FakeContainerServer) GetContainersCalls(stub func() ([]api.Container, error)) {
	fake.getContainersMutex.Lock()
	defer fake.getContainersMutex.Unlock()
	fake.GetContainersStub = stub
}

func (fake *FakeContainerServer) GetContainersReturns(result1 []api.Container, result2 error) {
	fake.getContainersMutex.Lock()
	defer fake.getContainersMutex.Unlock()
	fake.GetContainersStub = nil
	fake.getContainersReturns = struct {
		result1 []api.Container
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainersReturnsOnCall(i int, result1 []api.Container, result2 error) {
	fake.getContainersMutex.Lock()
	defer fake.getContainersMutex.Unlock()
	fake.GetContainersStub = nil
	if fake.getContainersReturnsOnCall == nil {
		fake.getContainersReturnsOnCall = make(map[int]struct {
			result1 []api.Container
			result2 error
		})
	}
	fake.getContainersReturnsOnCall[i] = struct {
		result1 []api.Container
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainersFull() ([]api.ContainerFull, error) {
	fake.getContainersFullMutex.Lock()
	ret, specificReturn := fake.getContainersFullReturnsOnCall[len(fake.getContainersFullArgsForCall)]
	fake.getContainersFullArgsForCall = append(fake.getContainersFullArgsForCall, struct {
	}{})
	stub := fake.GetContainersFullStub
	fakeReturns := fake.getContainersFullReturns
	fake.recordInvocation("GetContainersFull", []interface{}{})
	fake.getContainersFullMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetContainersFullCallCount() int {
	fake.getContainersFullMutex.RLock()
	defer fake.getContainersFullMutex.RUnlock()
	return len(fake.getContainersFullArgsForCall)
}

func (fake *FakeContainerServer) GetContainersFullCalls(stub func() ([]api.ContainerFull, error)) {
	fake.getContainersFullMutex.Lock()
	defer fake.getContainersFullMutex.Unlock()
	fake.GetContainersFullStub = stub
}

func (fake *FakeContainerServer) GetContainersFullReturns(result1 []api.ContainerFull, result2 error) {
	fake.getContainersFullMutex.Lock()
	defer fake.getContainersFullMutex.Unlock()
	fake.GetContainersFullStub = nil
	fake.getContainersFullReturns = struct {
		result1 []api.ContainerFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetContainersFullReturnsOnCall(i int, result1 []api.ContainerFull, result2 error) {
	fake.getContainersFullMutex.Lock()
	defer fake.getContainersFullMutex.Unlock()
	fake.GetContainersFullStub = nil
	if fake.getContainersFullReturnsOnCall == nil {
		fake.getContainersFullReturnsOnCall = make(map[int]struct {
			result1 []api.ContainerFull
			result2 error
		})
	}
	fake.getContainersFullReturnsOnCall[i] = struct {
		result1 []api.ContainerFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetEvents() (*lxd.EventListener, error) {
	fake.getEventsMutex.Lock()
	ret, specificReturn := fake.getEventsReturnsOnCall[len(fake.getEventsArgsForCall)]
	fake.getEventsArgsForCall = append(fake.getEventsArgsForCall, struct {
	}{})
	stub := fake.GetEventsStub
	fakeReturns := fake.getEventsReturns
	fake.recordInvocation("GetEvents", []interface{}{})
	fake.getEventsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetEventsCallCount() int {
	fake.getEventsMutex.RLock()
	defer fake.getEventsMutex.RUnlock()
	return len(fake.getEventsArgsForCall)
}

func (fake *FakeContainerServer) GetEventsCalls(stub func() (*lxd.EventListener, error)) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = stub
}

func (fake *FakeContainerServer) GetEventsReturns(result1 *lxd.EventListener, result2 error) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = nil
	fake.getEventsReturns = struct {
		result1 *lxd.EventListener
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetEventsReturnsOnCall(i int, result1 *lxd.EventListener, result2 error) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = nil
	if fake.getEventsReturnsOnCall == nil {
		fake.getEventsReturnsOnCall = make(map[int]struct {
			result1 *lxd.EventListener
			result2 error
		})
	}
	fake.getEventsReturnsOnCall[i] = struct {
		result1 *lxd.EventListener
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetEventsAllProjects() (*lxd.EventListener, error) {
	fake.getEventsAllProjectsMutex.Lock()
	ret, specificReturn := fake.getEventsAllProjectsReturnsOnCall[len(fake.getEventsAllProjectsArgsForCall)]
	fake.getEventsAllProjectsArgsForCall = append(fake.getEventsAllProjectsArgsForCall, struct {
	}{})
	stub := fake.GetEventsAllProjectsStub
	fakeReturns := fake.getEventsAllProjectsReturns
	fake.recordInvocation("GetEventsAllProjects", []interface{}{})
	fake.getEventsAllProjectsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetEventsAllProjectsCallCount() int {
	fake.getEventsAllProjectsMutex.RLock()
	defer fake.getEventsAllProjectsMutex.RUnlock()
	return len(fake.getEventsAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetEventsAllProjectsCalls(stub func() (*lxd.EventListener, error)) {
	fake.getEventsAllProjectsMutex.Lock()
	defer fake.getEventsAllProjectsMutex.Unlock()
	fake.GetEventsAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetEventsAllProjectsReturns(result1 *lxd.EventListener, result2 error) {
	fake.getEventsAllProjectsMutex.Lock()
	defer fake.getEventsAllProjectsMutex.Unlock()
	fake.GetEventsAllProjectsStub = nil
	fake.getEventsAllProjectsReturns = struct {
		result1 *lxd.EventListener
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetEventsAllProjectsReturnsOnCall(i int, result1 *lxd.EventListener, result2 error) {
	fake.getEventsAllProjectsMutex.Lock()
	defer fake.getEventsAllProjectsMutex.Unlock()
	fake.GetEventsAllProjectsStub = nil
	if fake.getEventsAllProjectsReturnsOnCall == nil {
		fake.getEventsAllProjectsReturnsOnCall = make(map[int]struct {
			result1 *lxd.EventListener
			result2 error
		})
	}
	fake.getEventsAllProjectsReturnsOnCall[i] = struct {
		result1 *lxd.EventListener
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetHTTPClient() (*http.Client, error) {
	fake.getHTTPClientMutex.Lock()
	ret, specificReturn := fake.getHTTPClientReturnsOnCall[len(fake.getHTTPClientArgsForCall)]
	fake.getHTTPClientArgsForCall = append(fake.getHTTPClientArgsForCall, struct {
	}{})
	stub := fake.GetHTTPClientStub
	fakeReturns := fake.getHTTPClientReturns
	fake.recordInvocation("GetHTTPClient", []interface{}{})
	fake.getHTTPClientMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetHTTPClientCallCount() int {
	fake.getHTTPClientMutex.RLock()
	defer fake.getHTTPClientMutex.RUnlock()
	return len(fake.getHTTPClientArgsForCall)
}

func (fake *FakeContainerServer) GetHTTPClientCalls(stub func() (*http.Client, error)) {
	fake.getHTTPClientMutex.Lock()
	defer fake.getHTTPClientMutex.Unlock()
	fake.GetHTTPClientStub = stub
}

func (fake *FakeContainerServer) GetHTTPClientReturns(result1 *http.Client, result2 error) {
	fake.getHTTPClientMutex.Lock()
	defer fake.getHTTPClientMutex.Unlock()
	fake.GetHTTPClientStub = nil
	fake.getHTTPClientReturns = struct {
		result1 *http.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetHTTPClientReturnsOnCall(i int, result1 *http.Client, result2 error) {
	fake.getHTTPClientMutex.Lock()
	defer fake.getHTTPClientMutex.Unlock()
	fake.GetHTTPClientStub = nil
	if fake.getHTTPClientReturnsOnCall == nil {
		fake.getHTTPClientReturnsOnCall = make(map[int]struct {
			result1 *http.Client
			result2 error
		})
	}
	fake.getHTTPClientReturnsOnCall[i] = struct {
		result1 *http.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImage(arg1 string) (*api.Image, string, error) {
	fake.getImageMutex.Lock()
	ret, specificReturn := fake.getImageReturnsOnCall[len(fake.getImageArgsForCall)]
	fake.getImageArgsForCall = append(fake.getImageArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetImageStub
	fakeReturns := fake.getImageReturns
	fake.recordInvocation("GetImage", []interface{}{arg1})
	fake.getImageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetImageCallCount() int {
	fake.getImageMutex.RLock()
	defer fake.getImageMutex.RUnlock()
	return len(fake.getImageArgsForCall)
}

func (fake *FakeContainerServer) GetImageCalls(stub func(string) (*api.Image, string, error)) {
	fake.getImageMutex.Lock()
	defer fake.getImageMutex.Unlock()
	fake.GetImageStub = stub
}

func (fake *FakeContainerServer) GetImageArgsForCall(i int) string {
	fake.getImageMutex.RLock()
	defer fake.getImageMutex.RUnlock()
	argsForCall := fake.getImageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetImageReturns(result1 *api.Image, result2 string, result3 error) {
	fake.getImageMutex.Lock()
	defer fake.getImageMutex.Unlock()
	fake.GetImageStub = nil
	fake.getImageReturns = struct {
		result1 *api.Image
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageReturnsOnCall(i int, result1 *api.Image, result2 string, result3 error) {
	fake.getImageMutex.Lock()
	defer fake.getImageMutex.Unlock()
	fake.GetImageStub = nil
	if fake.getImageReturnsOnCall == nil {
		fake.getImageReturnsOnCall = make(map[int]struct {
			result1 *api.Image
			result2 string
			result3 error
		})
	}
	fake.getImageReturnsOnCall[i] = struct {
		result1 *api.Image
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageAlias(arg1 string) (*api.ImageAliasesEntry, string, error) {
	fake.getImageAliasMutex.Lock()
	ret, specificReturn := fake.getImageAliasReturnsOnCall[len(fake.getImageAliasArgsForCall)]
	fake.getImageAliasArgsForCall = append(fake.getImageAliasArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetImageAliasStub
	fakeReturns := fake.getImageAliasReturns
	fake.recordInvocation("GetImageAlias", []interface{}{arg1})
	fake.getImageAliasMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetImageAliasCallCount() int {
	fake.getImageAliasMutex.RLock()
	defer fake.getImageAliasMutex.RUnlock()
	return len(fake.getImageAliasArgsForCall)
}

func (fake *FakeContainerServer) GetImageAliasCalls(stub func(string) (*api.ImageAliasesEntry, string, error)) {
	fake.getImageAliasMutex.Lock()
	defer fake.getImageAliasMutex.Unlock()
	fake.GetImageAliasStub = stub
}

func (fake *FakeContainerServer) GetImageAliasArgsForCall(i int) string {
	fake.getImageAliasMutex.RLock()
	defer fake.getImageAliasMutex.RUnlock()
	argsForCall := fake.getImageAliasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetImageAliasReturns(result1 *api.ImageAliasesEntry, result2 string, result3 error) {
	fake.getImageAliasMutex.Lock()
	defer fake.getImageAliasMutex.Unlock()
	fake.GetImageAliasStub = nil
	fake.getImageAliasReturns = struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageAliasReturnsOnCall(i int, result1 *api.ImageAliasesEntry, result2 string, result3 error) {
	fake.getImageAliasMutex.Lock()
	defer fake.getImageAliasMutex.Unlock()
	fake.GetImageAliasStub = nil
	if fake.getImageAliasReturnsOnCall == nil {
		fake.getImageAliasReturnsOnCall = make(map[int]struct {
			result1 *api.ImageAliasesEntry
			result2 string
			result3 error
		})
	}
	fake.getImageAliasReturnsOnCall[i] = struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageAliasArchitectures(arg1 string, arg2 string) (map[string]*api.ImageAliasesEntry, error) {
	fake.getImageAliasArchitecturesMutex.Lock()
	ret, specificReturn := fake.getImageAliasArchitecturesReturnsOnCall[len(fake.getImageAliasArchitecturesArgsForCall)]
	fake.getImageAliasArchitecturesArgsForCall = append(fake.getImageAliasArchitecturesArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetImageAliasArchitecturesStub
	fakeReturns := fake.getImageAliasArchitecturesReturns
	fake.recordInvocation("GetImageAliasArchitectures", []interface{}{arg1, arg2})
	fake.getImageAliasArchitecturesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageAliasArchitecturesCallCount() int {
	fake.getImageAliasArchitecturesMutex.RLock()
	defer fake.getImageAliasArchitecturesMutex.RUnlock()
	return len(fake.getImageAliasArchitecturesArgsForCall)
}

func (fake *FakeContainerServer) GetImageAliasArchitecturesCalls(stub func(string, string) (map[string]*api.ImageAliasesEntry, error)) {
	fake.getImageAliasArchitecturesMutex.Lock()
	defer fake.getImageAliasArchitecturesMutex.Unlock()
	fake.GetImageAliasArchitecturesStub = stub
}

func (fake *FakeContainerServer) GetImageAliasArchitecturesArgsForCall(i int) (string, string) {
	fake.getImageAliasArchitecturesMutex.RLock()
	defer fake.getImageAliasArchitecturesMutex.RUnlock()
	argsForCall := fake.getImageAliasArchitecturesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetImageAliasArchitecturesReturns(result1 map[string]*api.ImageAliasesEntry, result2 error) {
	fake.getImageAliasArchitecturesMutex.Lock()
	defer fake.getImageAliasArchitecturesMutex.Unlock()
	fake.GetImageAliasArchitecturesStub = nil
	fake.getImageAliasArchitecturesReturns = struct {
		result1 map[string]*api.ImageAliasesEntry
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageAliasArchitecturesReturnsOnCall(i int, result1 map[string]*api.ImageAliasesEntry, result2 error) {
	fake.getImageAliasArchitecturesMutex.Lock()
	defer fake.getImageAliasArchitecturesMutex.Unlock()
	fake.GetImageAliasArchitecturesStub = nil
	if fake.getImageAliasArchitecturesReturnsOnCall == nil {
		fake.getImageAliasArchitecturesReturnsOnCall = make(map[int]struct {
			result1 map[string]*api.ImageAliasesEntry
			result2 error
		})
	}
	fake.getImageAliasArchitecturesReturnsOnCall[i] = struct {
		result1 map[string]*api.ImageAliasesEntry
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageAliasNames() ([]string, error) {
	fake.getImageAliasNamesMutex.Lock()
	ret, specificReturn := fake.getImageAliasNamesReturnsOnCall[len(fake.getImageAliasNamesArgsForCall)]
	fake.getImageAliasNamesArgsForCall = append(fake.getImageAliasNamesArgsForCall, struct {
	}{})
	stub := fake.GetImageAliasNamesStub
	fakeReturns := fake.getImageAliasNamesReturns
	fake.recordInvocation("GetImageAliasNames", []interface{}{})
	fake.getImageAliasNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageAliasNamesCallCount() int {
	fake.getImageAliasNamesMutex.RLock()
	defer fake.getImageAliasNamesMutex.RUnlock()
	return len(fake.getImageAliasNamesArgsForCall)
}

func (fake *FakeContainerServer) GetImageAliasNamesCalls(stub func() ([]string, error)) {
	fake.getImageAliasNamesMutex.Lock()
	defer fake.getImageAliasNamesMutex.Unlock()
	fake.GetImageAliasNamesStub = stub
}

func (fake *FakeContainerServer) GetImageAliasNamesReturns(result1 []string, result2 error) {
	fake.getImageAliasNamesMutex.Lock()
	defer fake.getImageAliasNamesMutex.Unlock()
	fake.GetImageAliasNamesStub = nil
	fake.getImageAliasNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageAliasNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getImageAliasNamesMutex.Lock()
	defer fake.getImageAliasNamesMutex.Unlock()
	fake.GetImageAliasNamesStub = nil
	if fake.getImageAliasNamesReturnsOnCall == nil {
		fake.getImageAliasNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getImageAliasNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageAliasType(arg1 string, arg2 string) (*api.ImageAliasesEntry, string, error) {
	fake.getImageAliasTypeMutex.Lock()
	ret, specificReturn := fake.getImageAliasTypeReturnsOnCall[len(fake.getImageAliasTypeArgsForCall)]
	fake.getImageAliasTypeArgsForCall = append(fake.getImageAliasTypeArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetImageAliasTypeStub
	fakeReturns := fake.getImageAliasTypeReturns
	fake.recordInvocation("GetImageAliasType", []interface{}{arg1, arg2})
	fake.getImageAliasTypeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetImageAliasTypeCallCount() int {
	fake.getImageAliasTypeMutex.RLock()
	defer fake.getImageAliasTypeMutex.RUnlock()
	return len(fake.getImageAliasTypeArgsForCall)
}

func (fake *FakeContainerServer) GetImageAliasTypeCalls(stub func(string, string) (*api.ImageAliasesEntry, string, error)) {
	fake.getImageAliasTypeMutex.Lock()
	defer fake.getImageAliasTypeMutex.Unlock()
	fake.GetImageAliasTypeStub = stub
}

func (fake *FakeContainerServer) GetImageAliasTypeArgsForCall(i int) (string, string) {
	fake.getImageAliasTypeMutex.RLock()
	defer fake.getImageAliasTypeMutex.RUnlock()
	argsForCall := fake.getImageAliasTypeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetImageAliasTypeReturns(result1 *api.ImageAliasesEntry, result2 string, result3 error) {
	fake.getImageAliasTypeMutex.Lock()
	defer fake.getImageAliasTypeMutex.Unlock()
	fake.GetImageAliasTypeStub = nil
	fake.getImageAliasTypeReturns = struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageAliasTypeReturnsOnCall(i int, result1 *api.ImageAliasesEntry, result2 string, result3 error) {
	fake.getImageAliasTypeMutex.Lock()
	defer fake.getImageAliasTypeMutex.Unlock()
	fake.GetImageAliasTypeStub = nil
	if fake.getImageAliasTypeReturnsOnCall == nil {
		fake.getImageAliasTypeReturnsOnCall = make(map[int]struct {
			result1 *api.ImageAliasesEntry
			result2 string
			result3 error
		})
	}
	fake.getImageAliasTypeReturnsOnCall[i] = struct {
		result1 *api.ImageAliasesEntry
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetImageAliases() ([]api.ImageAliasesEntry, error) {
	fake.getImageAliasesMutex.Lock()
	ret, specificReturn := fake.getImageAliasesReturnsOnCall[len(fake.getImageAliasesArgsForCall)]
	fake.getImageAliasesArgsForCall = append(fake.getImageAliasesArgsForCall, struct {
	}{})
	stub := fake.GetImageAliasesStub
	fakeReturns := fake.getImageAliasesReturns
	fake.recordInvocation("GetImageAliases", []interface{}{})
	fake.getImageAliasesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageAliasesCallCount() int {
	fake.getImageAliasesMutex.RLock()
	defer fake.getImageAliasesMutex.RUnlock()
	return len(fake.getImageAliasesArgsForCall)
}

func (fake *FakeContainerServer) GetImageAliasesCalls(stub func() ([]api.ImageAliasesEntry, error)) {
	fake.getImageAliasesMutex.Lock()
	defer fake.getImageAliasesMutex.Unlock()
	fake.GetImageAliasesStub = stub
}

func (fake *FakeContainerServer) GetImageAliasesReturns(result1 []api.ImageAliasesEntry, result2 error) {
	fake.getImageAliasesMutex.Lock()
	defer fake.getImageAliasesMutex.Unlock()
	fake.GetImageAliasesStub = nil
	fake.getImageAliasesReturns = struct {
		result1 []api.ImageAliasesEntry
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageAliasesReturnsOnCall(i int, result1 []api.ImageAliasesEntry, result2 error) {
	fake.getImageAliasesMutex.Lock()
	defer fake.getImageAliasesMutex.Unlock()
	fake.GetImageAliasesStub = nil
	if fake.getImageAliasesReturnsOnCall == nil {
		fake.getImageAliasesReturnsOnCall = make(map[int]struct {
			result1 []api.ImageAliasesEntry
			result2 error
		})
	}
	fake.getImageAliasesReturnsOnCall[i] = struct {
		result1 []api.ImageAliasesEntry
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageFile(arg1 string, arg2 lxd.ImageFileRequest) (*lxd.ImageFileResponse, error) {
	fake.getImageFileMutex.Lock()
	ret, specificReturn := fake.getImageFileReturnsOnCall[len(fake.getImageFileArgsForCall)]
	fake.getImageFileArgsForCall = append(fake.getImageFileArgsForCall, struct {
		arg1 string
		arg2 lxd.ImageFileRequest
	}{arg1, arg2})
	stub := fake.GetImageFileStub
	fakeReturns := fake.getImageFileReturns
	fake.recordInvocation("GetImageFile", []interface{}{arg1, arg2})
	fake.getImageFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageFileCallCount() int {
	fake.getImageFileMutex.RLock()
	defer fake.getImageFileMutex.RUnlock()
	return len(fake.getImageFileArgsForCall)
}

func (fake *FakeContainerServer) GetImageFileCalls(stub func(string, lxd.ImageFileRequest) (*lxd.ImageFileResponse, error)) {
	fake.getImageFileMutex.Lock()
	defer fake.getImageFileMutex.Unlock()
	fake.GetImageFileStub = stub
}

func (fake *FakeContainerServer) GetImageFileArgsForCall(i int) (string, lxd.ImageFileRequest) {
	fake.getImageFileMutex.RLock()
	defer fake.getImageFileMutex.RUnlock()
	argsForCall := fake.getImageFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetImageFileReturns(result1 *lxd.ImageFileResponse, result2 error) {
	fake.getImageFileMutex.Lock()
	defer fake.getImageFileMutex.Unlock()
	fake.GetImageFileStub = nil
	fake.getImageFileReturns = struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageFileReturnsOnCall(i int, result1 *lxd.ImageFileResponse, result2 error) {
	fake.getImageFileMutex.Lock()
	defer fake.getImageFileMutex.Unlock()
	fake.GetImageFileStub = nil
	if fake.getImageFileReturnsOnCall == nil {
		fake.getImageFileReturnsOnCall = make(map[int]struct {
			result1 *lxd.ImageFileResponse
			result2 error
		})
	}
	fake.getImageFileReturnsOnCall[i] = struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageFingerprints() ([]string, error) {
	fake.getImageFingerprintsMutex.Lock()
	ret, specificReturn := fake.getImageFingerprintsReturnsOnCall[len(fake.getImageFingerprintsArgsForCall)]
	fake.getImageFingerprintsArgsForCall = append(fake.getImageFingerprintsArgsForCall, struct {
	}{})
	stub := fake.GetImageFingerprintsStub
	fakeReturns := fake.getImageFingerprintsReturns
	fake.recordInvocation("GetImageFingerprints", []interface{}{})
	fake.getImageFingerprintsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageFingerprintsCallCount() int {
	fake.getImageFingerprintsMutex.RLock()
	defer fake.getImageFingerprintsMutex.RUnlock()
	return len(fake.getImageFingerprintsArgsForCall)
}

func (fake *FakeContainerServer) GetImageFingerprintsCalls(stub func() ([]string, error)) {
	fake.getImageFingerprintsMutex.Lock()
	defer fake.getImageFingerprintsMutex.Unlock()
	fake.GetImageFingerprintsStub = stub
}

func (fake *FakeContainerServer) GetImageFingerprintsReturns(result1 []string, result2 error) {
	fake.getImageFingerprintsMutex.Lock()
	defer fake.getImageFingerprintsMutex.Unlock()
	fake.GetImageFingerprintsStub = nil
	fake.getImageFingerprintsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageFingerprintsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getImageFingerprintsMutex.Lock()
	defer fake.getImageFingerprintsMutex.Unlock()
	fake.GetImageFingerprintsStub = nil
	if fake.getImageFingerprintsReturnsOnCall == nil {
		fake.getImageFingerprintsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getImageFingerprintsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageSecret(arg1 string) (string, error) {
	fake.getImageSecretMutex.Lock()
	ret, specificReturn := fake.getImageSecretReturnsOnCall[len(fake.getImageSecretArgsForCall)]
	fake.getImageSecretArgsForCall = append(fake.getImageSecretArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetImageSecretStub
	fakeReturns := fake.getImageSecretReturns
	fake.recordInvocation("GetImageSecret", []interface{}{arg1})
	fake.getImageSecretMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImageSecretCallCount() int {
	fake.getImageSecretMutex.RLock()
	defer fake.getImageSecretMutex.RUnlock()
	return len(fake.getImageSecretArgsForCall)
}

func (fake *FakeContainerServer) GetImageSecretCalls(stub func(string) (string, error)) {
	fake.getImageSecretMutex.Lock()
	defer fake.getImageSecretMutex.Unlock()
	fake.GetImageSecretStub = stub
}

func (fake *FakeContainerServer) GetImageSecretArgsForCall(i int) string {
	fake.getImageSecretMutex.RLock()
	defer fake.getImageSecretMutex.RUnlock()
	argsForCall := fake.getImageSecretArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetImageSecretReturns(result1 string, result2 error) {
	fake.getImageSecretMutex.Lock()
	defer fake.getImageSecretMutex.Unlock()
	fake.GetImageSecretStub = nil
	fake.getImageSecretReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImageSecretReturnsOnCall(i int, result1 string, result2 error) {
	fake.getImageSecretMutex.Lock()
	defer fake.getImageSecretMutex.Unlock()
	fake.GetImageSecretStub = nil
	if fake.getImageSecretReturnsOnCall == nil {
		fake.getImageSecretReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getImageSecretReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImages() ([]api.Image, error) {
	fake.getImagesMutex.Lock()
	ret, specificReturn := fake.getImagesReturnsOnCall[len(fake.getImagesArgsForCall)]
	fake.getImagesArgsForCall = append(fake.getImagesArgsForCall, struct {
	}{})
	stub := fake.GetImagesStub
	fakeReturns := fake.getImagesReturns
	fake.recordInvocation("GetImages", []interface{}{})
	fake.getImagesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImagesCallCount() int {
	fake.getImagesMutex.RLock()
	defer fake.getImagesMutex.RUnlock()
	return len(fake.getImagesArgsForCall)
}

func (fake *FakeContainerServer) GetImagesCalls(stub func() ([]api.Image, error)) {
	fake.getImagesMutex.Lock()
	defer fake.getImagesMutex.Unlock()
	fake.GetImagesStub = stub
}

func (fake *FakeContainerServer) GetImagesReturns(result1 []api.Image, result2 error) {
	fake.getImagesMutex.Lock()
	defer fake.getImagesMutex.Unlock()
	fake.GetImagesStub = nil
	fake.getImagesReturns = struct {
		result1 []api.Image
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImagesReturnsOnCall(i int, result1 []api.Image, result2 error) {
	fake.getImagesMutex.Lock()
	defer fake.getImagesMutex.Unlock()
	fake.GetImagesStub = nil
	if fake.getImagesReturnsOnCall == nil {
		fake.getImagesReturnsOnCall = make(map[int]struct {
			result1 []api.Image
			result2 error
		})
	}
	fake.getImagesReturnsOnCall[i] = struct {
		result1 []api.Image
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImagesWithFilter(arg1 []string) ([]api.Image, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.getImagesWithFilterMutex.Lock()
	ret, specificReturn := fake.getImagesWithFilterReturnsOnCall[len(fake.getImagesWithFilterArgsForCall)]
	fake.getImagesWithFilterArgsForCall = append(fake.getImagesWithFilterArgsForCall, struct {
		arg1 []string
	}{arg1Copy})
	stub := fake.GetImagesWithFilterStub
	fakeReturns := fake.getImagesWithFilterReturns
	fake.recordInvocation("GetImagesWithFilter", []interface{}{arg1Copy})
	fake.getImagesWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetImagesWithFilterCallCount() int {
	fake.getImagesWithFilterMutex.RLock()
	defer fake.getImagesWithFilterMutex.RUnlock()
	return len(fake.getImagesWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetImagesWithFilterCalls(stub func([]string) ([]api.Image, error)) {
	fake.getImagesWithFilterMutex.Lock()
	defer fake.getImagesWithFilterMutex.Unlock()
	fake.GetImagesWithFilterStub = stub
}

func (fake *FakeContainerServer) GetImagesWithFilterArgsForCall(i int) []string {
	fake.getImagesWithFilterMutex.RLock()
	defer fake.getImagesWithFilterMutex.RUnlock()
	argsForCall := fake.getImagesWithFilterArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetImagesWithFilterReturns(result1 []api.Image, result2 error) {
	fake.getImagesWithFilterMutex.Lock()
	defer fake.getImagesWithFilterMutex.Unlock()
	fake.GetImagesWithFilterStub = nil
	fake.getImagesWithFilterReturns = struct {
		result1 []api.Image
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetImagesWithFilterReturnsOnCall(i int, result1 []api.Image, result2 error) {
	fake.getImagesWithFilterMutex.Lock()
	defer fake.getImagesWithFilterMutex.Unlock()
	fake.GetImagesWithFilterStub = nil
	if fake.getImagesWithFilterReturnsOnCall == nil {
		fake.getImagesWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.Image
			result2 error
		})
	}
	fake.getImagesWithFilterReturnsOnCall[i] = struct {
		result1 []api.Image
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstance(arg1 string) (*api.Instance, string, error) {
	fake.getInstanceMutex.Lock()
	ret, specificReturn := fake.getInstanceReturnsOnCall[len(fake.getInstanceArgsForCall)]
	fake.getInstanceArgsForCall = append(fake.getInstanceArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceStub
	fakeReturns := fake.getInstanceReturns
	fake.recordInvocation("GetInstance", []interface{}{arg1})
	fake.getInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceCallCount() int {
	fake.getInstanceMutex.RLock()
	defer fake.getInstanceMutex.RUnlock()
	return len(fake.getInstanceArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceCalls(stub func(string) (*api.Instance, string, error)) {
	fake.getInstanceMutex.Lock()
	defer fake.getInstanceMutex.Unlock()
	fake.GetInstanceStub = stub
}

func (fake *FakeContainerServer) GetInstanceArgsForCall(i int) string {
	fake.getInstanceMutex.RLock()
	defer fake.getInstanceMutex.RUnlock()
	argsForCall := fake.getInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceReturns(result1 *api.Instance, result2 string, result3 error) {
	fake.getInstanceMutex.Lock()
	defer fake.getInstanceMutex.Unlock()
	fake.GetInstanceStub = nil
	fake.getInstanceReturns = struct {
		result1 *api.Instance
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceReturnsOnCall(i int, result1 *api.Instance, result2 string, result3 error) {
	fake.getInstanceMutex.Lock()
	defer fake.getInstanceMutex.Unlock()
	fake.GetInstanceStub = nil
	if fake.getInstanceReturnsOnCall == nil {
		fake.getInstanceReturnsOnCall = make(map[int]struct {
			result1 *api.Instance
			result2 string
			result3 error
		})
	}
	fake.getInstanceReturnsOnCall[i] = struct {
		result1 *api.Instance
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceBackup(arg1 string, arg2 string) (*api.InstanceBackup, string, error) {
	fake.getInstanceBackupMutex.Lock()
	ret, specificReturn := fake.getInstanceBackupReturnsOnCall[len(fake.getInstanceBackupArgsForCall)]
	fake.getInstanceBackupArgsForCall = append(fake.getInstanceBackupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetInstanceBackupStub
	fakeReturns := fake.getInstanceBackupReturns
	fake.recordInvocation("GetInstanceBackup", []interface{}{arg1, arg2})
	fake.getInstanceBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceBackupCallCount() int {
	fake.getInstanceBackupMutex.RLock()
	defer fake.getInstanceBackupMutex.RUnlock()
	return len(fake.getInstanceBackupArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceBackupCalls(stub func(string, string) (*api.InstanceBackup, string, error)) {
	fake.getInstanceBackupMutex.Lock()
	defer fake.getInstanceBackupMutex.Unlock()
	fake.GetInstanceBackupStub = stub
}

func (fake *FakeContainerServer) GetInstanceBackupArgsForCall(i int) (string, string) {
	fake.getInstanceBackupMutex.RLock()
	defer fake.getInstanceBackupMutex.RUnlock()
	argsForCall := fake.getInstanceBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceBackupReturns(result1 *api.InstanceBackup, result2 string, result3 error) {
	fake.getInstanceBackupMutex.Lock()
	defer fake.getInstanceBackupMutex.Unlock()
	fake.GetInstanceBackupStub = nil
	fake.getInstanceBackupReturns = struct {
		result1 *api.InstanceBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceBackupReturnsOnCall(i int, result1 *api.InstanceBackup, result2 string, result3 error) {
	fake.getInstanceBackupMutex.Lock()
	defer fake.getInstanceBackupMutex.Unlock()
	fake.GetInstanceBackupStub = nil
	if fake.getInstanceBackupReturnsOnCall == nil {
		fake.getInstanceBackupReturnsOnCall = make(map[int]struct {
			result1 *api.InstanceBackup
			result2 string
			result3 error
		})
	}
	fake.getInstanceBackupReturnsOnCall[i] = struct {
		result1 *api.InstanceBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceBackupFile(arg1 string, arg2 string, arg3 *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error) {
	fake.getInstanceBackupFileMutex.Lock()
	ret, specificReturn := fake.getInstanceBackupFileReturnsOnCall[len(fake.getInstanceBackupFileArgsForCall)]
	fake.getInstanceBackupFileArgsForCall = append(fake.getInstanceBackupFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 *lxd.BackupFileRequest
	}{arg1, arg2, arg3})
	stub := fake.GetInstanceBackupFileStub
	fakeReturns := fake.getInstanceBackupFileReturns
	fake.recordInvocation("GetInstanceBackupFile", []interface{}{arg1, arg2, arg3})
	fake.getInstanceBackupFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceBackupFileCallCount() int {
	fake.getInstanceBackupFileMutex.RLock()
	defer fake.getInstanceBackupFileMutex.RUnlock()
	return len(fake.getInstanceBackupFileArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceBackupFileCalls(stub func(string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)) {
	fake.getInstanceBackupFileMutex.Lock()
	defer fake.getInstanceBackupFileMutex.Unlock()
	fake.GetInstanceBackupFileStub = stub
}

func (fake *FakeContainerServer) GetInstanceBackupFileArgsForCall(i int) (string, string, *lxd.BackupFileRequest) {
	fake.getInstanceBackupFileMutex.RLock()
	defer fake.getInstanceBackupFileMutex.RUnlock()
	argsForCall := fake.getInstanceBackupFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetInstanceBackupFileReturns(result1 *lxd.BackupFileResponse, result2 error) {
	fake.getInstanceBackupFileMutex.Lock()
	defer fake.getInstanceBackupFileMutex.Unlock()
	fake.GetInstanceBackupFileStub = nil
	fake.getInstanceBackupFileReturns = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceBackupFileReturnsOnCall(i int, result1 *lxd.BackupFileResponse, result2 error) {
	fake.getInstanceBackupFileMutex.Lock()
	defer fake.getInstanceBackupFileMutex.Unlock()
	fake.GetInstanceBackupFileStub = nil
	if fake.getInstanceBackupFileReturnsOnCall == nil {
		fake.getInstanceBackupFileReturnsOnCall = make(map[int]struct {
			result1 *lxd.BackupFileResponse
			result2 error
		})
	}
	fake.getInstanceBackupFileReturnsOnCall[i] = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceBackupNames(arg1 string) ([]string, error) {
	fake.getInstanceBackupNamesMutex.Lock()
	ret, specificReturn := fake.getInstanceBackupNamesReturnsOnCall[len(fake.getInstanceBackupNamesArgsForCall)]
	fake.getInstanceBackupNamesArgsForCall = append(fake.getInstanceBackupNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceBackupNamesStub
	fakeReturns := fake.getInstanceBackupNamesReturns
	fake.recordInvocation("GetInstanceBackupNames", []interface{}{arg1})
	fake.getInstanceBackupNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceBackupNamesCallCount() int {
	fake.getInstanceBackupNamesMutex.RLock()
	defer fake.getInstanceBackupNamesMutex.RUnlock()
	return len(fake.getInstanceBackupNamesArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceBackupNamesCalls(stub func(string) ([]string, error)) {
	fake.getInstanceBackupNamesMutex.Lock()
	defer fake.getInstanceBackupNamesMutex.Unlock()
	fake.GetInstanceBackupNamesStub = stub
}

func (fake *FakeContainerServer) GetInstanceBackupNamesArgsForCall(i int) string {
	fake.getInstanceBackupNamesMutex.RLock()
	defer fake.getInstanceBackupNamesMutex.RUnlock()
	argsForCall := fake.getInstanceBackupNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceBackupNamesReturns(result1 []string, result2 error) {
	fake.getInstanceBackupNamesMutex.Lock()
	defer fake.getInstanceBackupNamesMutex.Unlock()
	fake.GetInstanceBackupNamesStub = nil
	fake.getInstanceBackupNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceBackupNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getInstanceBackupNamesMutex.Lock()
	defer fake.getInstanceBackupNamesMutex.Unlock()
	fake.GetInstanceBackupNamesStub = nil
	if fake.getInstanceBackupNamesReturnsOnCall == nil {
		fake.getInstanceBackupNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getInstanceBackupNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceBackups(arg1 string) ([]api.InstanceBackup, error) {
	fake.getInstanceBackupsMutex.Lock()
	ret, specificReturn := fake.getInstanceBackupsReturnsOnCall[len(fake.getInstanceBackupsArgsForCall)]
	fake.getInstanceBackupsArgsForCall = append(fake.getInstanceBackupsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceBackupsStub
	fakeReturns := fake.getInstanceBackupsReturns
	fake.recordInvocation("GetInstanceBackups", []interface{}{arg1})
	fake.getInstanceBackupsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceBackupsCallCount() int {
	fake.getInstanceBackupsMutex.RLock()
	defer fake.getInstanceBackupsMutex.RUnlock()
	return len(fake.getInstanceBackupsArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceBackupsCalls(stub func(string) ([]api.InstanceBackup, error)) {
	fake.getInstanceBackupsMutex.Lock()
	defer fake.getInstanceBackupsMutex.Unlock()
	fake.GetInstanceBackupsStub = stub
}

func (fake *FakeContainerServer) GetInstanceBackupsArgsForCall(i int) string {
	fake.getInstanceBackupsMutex.RLock()
	defer fake.getInstanceBackupsMutex.RUnlock()
	argsForCall := fake.getInstanceBackupsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceBackupsReturns(result1 []api.InstanceBackup, result2 error) {
	fake.getInstanceBackupsMutex.Lock()
	defer fake.getInstanceBackupsMutex.Unlock()
	fake.GetInstanceBackupsStub = nil
	fake.getInstanceBackupsReturns = struct {
		result1 []api.InstanceBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceBackupsReturnsOnCall(i int, result1 []api.InstanceBackup, result2 error) {
	fake.getInstanceBackupsMutex.Lock()
	defer fake.getInstanceBackupsMutex.Unlock()
	fake.GetInstanceBackupsStub = nil
	if fake.getInstanceBackupsReturnsOnCall == nil {
		fake.getInstanceBackupsReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceBackup
			result2 error
		})
	}
	fake.getInstanceBackupsReturnsOnCall[i] = struct {
		result1 []api.InstanceBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceConsoleLog(arg1 string, arg2 *lxd.InstanceConsoleLogArgs) (io.ReadCloser, error) {
	fake.getInstanceConsoleLogMutex.Lock()
	ret, specificReturn := fake.getInstanceConsoleLogReturnsOnCall[len(fake.getInstanceConsoleLogArgsForCall)]
	fake.getInstanceConsoleLogArgsForCall = append(fake.getInstanceConsoleLogArgsForCall, struct {
		arg1 string
		arg2 *lxd.InstanceConsoleLogArgs
	}{arg1, arg2})
	stub := fake.GetInstanceConsoleLogStub
	fakeReturns := fake.getInstanceConsoleLogReturns
	fake.recordInvocation("GetInstanceConsoleLog", []interface{}{arg1, arg2})
	fake.getInstanceConsoleLogMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceConsoleLogCallCount() int {
	fake.getInstanceConsoleLogMutex.RLock()
	defer fake.getInstanceConsoleLogMutex.RUnlock()
	return len(fake.getInstanceConsoleLogArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceConsoleLogCalls(stub func(string, *lxd.InstanceConsoleLogArgs) (io.ReadCloser, error)) {
	fake.getInstanceConsoleLogMutex.Lock()
	defer fake.getInstanceConsoleLogMutex.Unlock()
	fake.GetInstanceConsoleLogStub = stub
}

func (fake *FakeContainerServer) GetInstanceConsoleLogArgsForCall(i int) (string, *lxd.InstanceConsoleLogArgs) {
	fake.getInstanceConsoleLogMutex.RLock()
	defer fake.getInstanceConsoleLogMutex.RUnlock()
	argsForCall := fake.getInstanceConsoleLogArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceConsoleLogReturns(result1 io.ReadCloser, result2 error) {
	fake.getInstanceConsoleLogMutex.Lock()
	defer fake.getInstanceConsoleLogMutex.Unlock()
	fake.GetInstanceConsoleLogStub = nil
	fake.getInstanceConsoleLogReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceConsoleLogReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getInstanceConsoleLogMutex.Lock()
	defer fake.getInstanceConsoleLogMutex.Unlock()
	fake.GetInstanceConsoleLogStub = nil
	if fake.getInstanceConsoleLogReturnsOnCall == nil {
		fake.getInstanceConsoleLogReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getInstanceConsoleLogReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceFile(arg1 string, arg2 string) (io.ReadCloser, *lxd.InstanceFileResponse, error) {
	fake.getInstanceFileMutex.Lock()
	ret, specificReturn := fake.getInstanceFileReturnsOnCall[len(fake.getInstanceFileArgsForCall)]
	fake.getInstanceFileArgsForCall = append(fake.getInstanceFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetInstanceFileStub
	fakeReturns := fake.getInstanceFileReturns
	fake.recordInvocation("GetInstanceFile", []interface{}{arg1, arg2})
	fake.getInstanceFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceFileCallCount() int {
	fake.getInstanceFileMutex.RLock()
	defer fake.getInstanceFileMutex.RUnlock()
	return len(fake.getInstanceFileArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceFileCalls(stub func(string, string) (io.ReadCloser, *lxd.InstanceFileResponse, error)) {
	fake.getInstanceFileMutex.Lock()
	defer fake.getInstanceFileMutex.Unlock()
	fake.GetInstanceFileStub = stub
}

func (fake *FakeContainerServer) GetInstanceFileArgsForCall(i int) (string, string) {
	fake.getInstanceFileMutex.RLock()
	defer fake.getInstanceFileMutex.RUnlock()
	argsForCall := fake.getInstanceFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceFileReturns(result1 io.ReadCloser, result2 *lxd.InstanceFileResponse, result3 error) {
	fake.getInstanceFileMutex.Lock()
	defer fake.getInstanceFileMutex.Unlock()
	fake.GetInstanceFileStub = nil
	fake.getInstanceFileReturns = struct {
		result1 io.ReadCloser
		result2 *lxd.InstanceFileResponse
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceFileReturnsOnCall(i int, result1 io.ReadCloser, result2 *lxd.InstanceFileResponse, result3 error) {
	fake.getInstanceFileMutex.Lock()
	defer fake.getInstanceFileMutex.Unlock()
	fake.GetInstanceFileStub = nil
	if fake.getInstanceFileReturnsOnCall == nil {
		fake.getInstanceFileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 *lxd.InstanceFileResponse
			result3 error
		})
	}
	fake.getInstanceFileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 *lxd.InstanceFileResponse
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceFileSFTP(arg1 string) (*sftp.Client, error) {
	fake.getInstanceFileSFTPMutex.Lock()
	ret, specificReturn := fake.getInstanceFileSFTPReturnsOnCall[len(fake.getInstanceFileSFTPArgsForCall)]
	fake.getInstanceFileSFTPArgsForCall = append(fake.getInstanceFileSFTPArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceFileSFTPStub
	fakeReturns := fake.getInstanceFileSFTPReturns
	fake.recordInvocation("GetInstanceFileSFTP", []interface{}{arg1})
	fake.getInstanceFileSFTPMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceFileSFTPCallCount() int {
	fake.getInstanceFileSFTPMutex.RLock()
	defer fake.getInstanceFileSFTPMutex.RUnlock()
	return len(fake.getInstanceFileSFTPArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceFileSFTPCalls(stub func(string) (*sftp.Client, error)) {
	fake.getInstanceFileSFTPMutex.Lock()
	defer fake.getInstanceFileSFTPMutex.Unlock()
	fake.GetInstanceFileSFTPStub = stub
}

func (fake *FakeContainerServer) GetInstanceFileSFTPArgsForCall(i int) string {
	fake.getInstanceFileSFTPMutex.RLock()
	defer fake.getInstanceFileSFTPMutex.RUnlock()
	argsForCall := fake.getInstanceFileSFTPArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceFileSFTPReturns(result1 *sftp.Client, result2 error) {
	fake.getInstanceFileSFTPMutex.Lock()
	defer fake.getInstanceFileSFTPMutex.Unlock()
	fake.GetInstanceFileSFTPStub = nil
	fake.getInstanceFileSFTPReturns = struct {
		result1 *sftp.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceFileSFTPReturnsOnCall(i int, result1 *sftp.Client, result2 error) {
	fake.getInstanceFileSFTPMutex.Lock()
	defer fake.getInstanceFileSFTPMutex.Unlock()
	fake.GetInstanceFileSFTPStub = nil
	if fake.getInstanceFileSFTPReturnsOnCall == nil {
		fake.getInstanceFileSFTPReturnsOnCall = make(map[int]struct {
			result1 *sftp.Client
			result2 error
		})
	}
	fake.getInstanceFileSFTPReturnsOnCall[i] = struct {
		result1 *sftp.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConn(arg1 string) (net.Conn, error) {
	fake.getInstanceFileSFTPConnMutex.Lock()
	ret, specificReturn := fake.getInstanceFileSFTPConnReturnsOnCall[len(fake.getInstanceFileSFTPConnArgsForCall)]
	fake.getInstanceFileSFTPConnArgsForCall = append(fake.getInstanceFileSFTPConnArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceFileSFTPConnStub
	fakeReturns := fake.getInstanceFileSFTPConnReturns
	fake.recordInvocation("GetInstanceFileSFTPConn", []interface{}{arg1})
	fake.getInstanceFileSFTPConnMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConnCallCount() int {
	fake.getInstanceFileSFTPConnMutex.RLock()
	defer fake.getInstanceFileSFTPConnMutex.RUnlock()
	return len(fake.getInstanceFileSFTPConnArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConnCalls(stub func(string) (net.Conn, error)) {
	fake.getInstanceFileSFTPConnMutex.Lock()
	defer fake.getInstanceFileSFTPConnMutex.Unlock()
	fake.GetInstanceFileSFTPConnStub = stub
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConnArgsForCall(i int) string {
	fake.getInstanceFileSFTPConnMutex.RLock()
	defer fake.getInstanceFileSFTPConnMutex.RUnlock()
	argsForCall := fake.getInstanceFileSFTPConnArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConnReturns(result1 net.Conn, result2 error) {
	fake.getInstanceFileSFTPConnMutex.Lock()
	defer fake.getInstanceFileSFTPConnMutex.Unlock()
	fake.GetInstanceFileSFTPConnStub = nil
	fake.getInstanceFileSFTPConnReturns = struct {
		result1 net.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceFileSFTPConnReturnsOnCall(i int, result1 net.Conn, result2 error) {
	fake.getInstanceFileSFTPConnMutex.Lock()
	defer fake.getInstanceFileSFTPConnMutex.Unlock()
	fake.GetInstanceFileSFTPConnStub = nil
	if fake.getInstanceFileSFTPConnReturnsOnCall == nil {
		fake.getInstanceFileSFTPConnReturnsOnCall = make(map[int]struct {
			result1 net.Conn
			result2 error
		})
	}
	fake.getInstanceFileSFTPConnReturnsOnCall[i] = struct {
		result1 net.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceFull(arg1 string) (*api.InstanceFull, string, error) {
	fake.getInstanceFullMutex.Lock()
	ret, specificReturn := fake.getInstanceFullReturnsOnCall[len(fake.getInstanceFullArgsForCall)]
	fake.getInstanceFullArgsForCall = append(fake.getInstanceFullArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceFullStub
	fakeReturns := fake.getInstanceFullReturns
	fake.recordInvocation("GetInstanceFull", []interface{}{arg1})
	fake.getInstanceFullMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceFullCallCount() int {
	fake.getInstanceFullMutex.RLock()
	defer fake.getInstanceFullMutex.RUnlock()
	return len(fake.getInstanceFullArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceFullCalls(stub func(string) (*api.InstanceFull, string, error)) {
	fake.getInstanceFullMutex.Lock()
	defer fake.getInstanceFullMutex.Unlock()
	fake.GetInstanceFullStub = stub
}

func (fake *FakeContainerServer) GetInstanceFullArgsForCall(i int) string {
	fake.getInstanceFullMutex.RLock()
	defer fake.getInstanceFullMutex.RUnlock()
	argsForCall := fake.getInstanceFullArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceFullReturns(result1 *api.InstanceFull, result2 string, result3 error) {
	fake.getInstanceFullMutex.Lock()
	defer fake.getInstanceFullMutex.Unlock()
	fake.GetInstanceFullStub = nil
	fake.getInstanceFullReturns = struct {
		result1 *api.InstanceFull
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceFullReturnsOnCall(i int, result1 *api.InstanceFull, result2 string, result3 error) {
	fake.getInstanceFullMutex.Lock()
	defer fake.getInstanceFullMutex.Unlock()
	fake.GetInstanceFullStub = nil
	if fake.getInstanceFullReturnsOnCall == nil {
		fake.getInstanceFullReturnsOnCall = make(map[int]struct {
			result1 *api.InstanceFull
			result2 string
			result3 error
		})
	}
	fake.getInstanceFullReturnsOnCall[i] = struct {
		result1 *api.InstanceFull
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceLogfile(arg1 string, arg2 string) (io.ReadCloser, error) {
	fake.getInstanceLogfileMutex.Lock()
	ret, specificReturn := fake.getInstanceLogfileReturnsOnCall[len(fake.getInstanceLogfileArgsForCall)]
	fake.getInstanceLogfileArgsForCall = append(fake.getInstanceLogfileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetInstanceLogfileStub
	fakeReturns := fake.getInstanceLogfileReturns
	fake.recordInvocation("GetInstanceLogfile", []interface{}{arg1, arg2})
	fake.getInstanceLogfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceLogfileCallCount() int {
	fake.getInstanceLogfileMutex.RLock()
	defer fake.getInstanceLogfileMutex.RUnlock()
	return len(fake.getInstanceLogfileArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceLogfileCalls(stub func(string, string) (io.ReadCloser, error)) {
	fake.getInstanceLogfileMutex.Lock()
	defer fake.getInstanceLogfileMutex.Unlock()
	fake.GetInstanceLogfileStub = stub
}

func (fake *FakeContainerServer) GetInstanceLogfileArgsForCall(i int) (string, string) {
	fake.getInstanceLogfileMutex.RLock()
	defer fake.getInstanceLogfileMutex.RUnlock()
	argsForCall := fake.getInstanceLogfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceLogfileReturns(result1 io.ReadCloser, result2 error) {
	fake.getInstanceLogfileMutex.Lock()
	defer fake.getInstanceLogfileMutex.Unlock()
	fake.GetInstanceLogfileStub = nil
	fake.getInstanceLogfileReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceLogfileReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getInstanceLogfileMutex.Lock()
	defer fake.getInstanceLogfileMutex.Unlock()
	fake.GetInstanceLogfileStub = nil
	if fake.getInstanceLogfileReturnsOnCall == nil {
		fake.getInstanceLogfileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getInstanceLogfileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceLogfiles(arg1 string) ([]string, error) {
	fake.getInstanceLogfilesMutex.Lock()
	ret, specificReturn := fake.getInstanceLogfilesReturnsOnCall[len(fake.getInstanceLogfilesArgsForCall)]
	fake.getInstanceLogfilesArgsForCall = append(fake.getInstanceLogfilesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceLogfilesStub
	fakeReturns := fake.getInstanceLogfilesReturns
	fake.recordInvocation("GetInstanceLogfiles", []interface{}{arg1})
	fake.getInstanceLogfilesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceLogfilesCallCount() int {
	fake.getInstanceLogfilesMutex.RLock()
	defer fake.getInstanceLogfilesMutex.RUnlock()
	return len(fake.getInstanceLogfilesArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceLogfilesCalls(stub func(string) ([]string, error)) {
	fake.getInstanceLogfilesMutex.Lock()
	defer fake.getInstanceLogfilesMutex.Unlock()
	fake.GetInstanceLogfilesStub = stub
}

func (fake *FakeContainerServer) GetInstanceLogfilesArgsForCall(i int) string {
	fake.getInstanceLogfilesMutex.RLock()
	defer fake.getInstanceLogfilesMutex.RUnlock()
	argsForCall := fake.getInstanceLogfilesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceLogfilesReturns(result1 []string, result2 error) {
	fake.getInstanceLogfilesMutex.Lock()
	defer fake.getInstanceLogfilesMutex.Unlock()
	fake.GetInstanceLogfilesStub = nil
	fake.getInstanceLogfilesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceLogfilesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getInstanceLogfilesMutex.Lock()
	defer fake.getInstanceLogfilesMutex.Unlock()
	fake.GetInstanceLogfilesStub = nil
	if fake.getInstanceLogfilesReturnsOnCall == nil {
		fake.getInstanceLogfilesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getInstanceLogfilesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceMetadata(arg1 string) (*api.ImageMetadata, string, error) {
	fake.getInstanceMetadataMutex.Lock()
	ret, specificReturn := fake.getInstanceMetadataReturnsOnCall[len(fake.getInstanceMetadataArgsForCall)]
	fake.getInstanceMetadataArgsForCall = append(fake.getInstanceMetadataArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceMetadataStub
	fakeReturns := fake.getInstanceMetadataReturns
	fake.recordInvocation("GetInstanceMetadata", []interface{}{arg1})
	fake.getInstanceMetadataMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceMetadataCallCount() int {
	fake.getInstanceMetadataMutex.RLock()
	defer fake.getInstanceMetadataMutex.RUnlock()
	return len(fake.getInstanceMetadataArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceMetadataCalls(stub func(string) (*api.ImageMetadata, string, error)) {
	fake.getInstanceMetadataMutex.Lock()
	defer fake.getInstanceMetadataMutex.Unlock()
	fake.GetInstanceMetadataStub = stub
}

func (fake *FakeContainerServer) GetInstanceMetadataArgsForCall(i int) string {
	fake.getInstanceMetadataMutex.RLock()
	defer fake.getInstanceMetadataMutex.RUnlock()
	argsForCall := fake.getInstanceMetadataArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceMetadataReturns(result1 *api.ImageMetadata, result2 string, result3 error) {
	fake.getInstanceMetadataMutex.Lock()
	defer fake.getInstanceMetadataMutex.Unlock()
	fake.GetInstanceMetadataStub = nil
	fake.getInstanceMetadataReturns = struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceMetadataReturnsOnCall(i int, result1 *api.ImageMetadata, result2 string, result3 error) {
	fake.getInstanceMetadataMutex.Lock()
	defer fake.getInstanceMetadataMutex.Unlock()
	fake.GetInstanceMetadataStub = nil
	if fake.getInstanceMetadataReturnsOnCall == nil {
		fake.getInstanceMetadataReturnsOnCall = make(map[int]struct {
			result1 *api.ImageMetadata
			result2 string
			result3 error
		})
	}
	fake.getInstanceMetadataReturnsOnCall[i] = struct {
		result1 *api.ImageMetadata
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceNames(arg1 api.InstanceType) ([]string, error) {
	fake.getInstanceNamesMutex.Lock()
	ret, specificReturn := fake.getInstanceNamesReturnsOnCall[len(fake.getInstanceNamesArgsForCall)]
	fake.getInstanceNamesArgsForCall = append(fake.getInstanceNamesArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstanceNamesStub
	fakeReturns := fake.getInstanceNamesReturns
	fake.recordInvocation("GetInstanceNames", []interface{}{arg1})
	fake.getInstanceNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceNamesCallCount() int {
	fake.getInstanceNamesMutex.RLock()
	defer fake.getInstanceNamesMutex.RUnlock()
	return len(fake.getInstanceNamesArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceNamesCalls(stub func(api.InstanceType) ([]string, error)) {
	fake.getInstanceNamesMutex.Lock()
	defer fake.getInstanceNamesMutex.Unlock()
	fake.GetInstanceNamesStub = stub
}

func (fake *FakeContainerServer) GetInstanceNamesArgsForCall(i int) api.InstanceType {
	fake.getInstanceNamesMutex.RLock()
	defer fake.getInstanceNamesMutex.RUnlock()
	argsForCall := fake.getInstanceNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceNamesReturns(result1 []string, result2 error) {
	fake.getInstanceNamesMutex.Lock()
	defer fake.getInstanceNamesMutex.Unlock()
	fake.GetInstanceNamesStub = nil
	fake.getInstanceNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getInstanceNamesMutex.Lock()
	defer fake.getInstanceNamesMutex.Unlock()
	fake.GetInstanceNamesStub = nil
	if fake.getInstanceNamesReturnsOnCall == nil {
		fake.getInstanceNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getInstanceNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjects(arg1 api.InstanceType) (map[string][]string, error) {
	fake.getInstanceNamesAllProjectsMutex.Lock()
	ret, specificReturn := fake.getInstanceNamesAllProjectsReturnsOnCall[len(fake.getInstanceNamesAllProjectsArgsForCall)]
	fake.getInstanceNamesAllProjectsArgsForCall = append(fake.getInstanceNamesAllProjectsArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstanceNamesAllProjectsStub
	fakeReturns := fake.getInstanceNamesAllProjectsReturns
	fake.recordInvocation("GetInstanceNamesAllProjects", []interface{}{arg1})
	fake.getInstanceNamesAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjectsCallCount() int {
	fake.getInstanceNamesAllProjectsMutex.RLock()
	defer fake.getInstanceNamesAllProjectsMutex.RUnlock()
	return len(fake.getInstanceNamesAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjectsCalls(stub func(api.InstanceType) (map[string][]string, error)) {
	fake.getInstanceNamesAllProjectsMutex.Lock()
	defer fake.getInstanceNamesAllProjectsMutex.Unlock()
	fake.GetInstanceNamesAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjectsArgsForCall(i int) api.InstanceType {
	fake.getInstanceNamesAllProjectsMutex.RLock()
	defer fake.getInstanceNamesAllProjectsMutex.RUnlock()
	argsForCall := fake.getInstanceNamesAllProjectsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjectsReturns(result1 map[string][]string, result2 error) {
	fake.getInstanceNamesAllProjectsMutex.Lock()
	defer fake.getInstanceNamesAllProjectsMutex.Unlock()
	fake.GetInstanceNamesAllProjectsStub = nil
	fake.getInstanceNamesAllProjectsReturns = struct {
		result1 map[string][]string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceNamesAllProjectsReturnsOnCall(i int, result1 map[string][]string, result2 error) {
	fake.getInstanceNamesAllProjectsMutex.Lock()
	defer fake.getInstanceNamesAllProjectsMutex.Unlock()
	fake.GetInstanceNamesAllProjectsStub = nil
	if fake.getInstanceNamesAllProjectsReturnsOnCall == nil {
		fake.getInstanceNamesAllProjectsReturnsOnCall = make(map[int]struct {
			result1 map[string][]string
			result2 error
		})
	}
	fake.getInstanceNamesAllProjectsReturnsOnCall[i] = struct {
		result1 map[string][]string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceSnapshot(arg1 string, arg2 string) (*api.InstanceSnapshot, string, error) {
	fake.getInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.getInstanceSnapshotReturnsOnCall[len(fake.getInstanceSnapshotArgsForCall)]
	fake.getInstanceSnapshotArgsForCall = append(fake.getInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetInstanceSnapshotStub
	fakeReturns := fake.getInstanceSnapshotReturns
	fake.recordInvocation("GetInstanceSnapshot", []interface{}{arg1, arg2})
	fake.getInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceSnapshotCallCount() int {
	fake.getInstanceSnapshotMutex.RLock()
	defer fake.getInstanceSnapshotMutex.RUnlock()
	return len(fake.getInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceSnapshotCalls(stub func(string, string) (*api.InstanceSnapshot, string, error)) {
	fake.getInstanceSnapshotMutex.Lock()
	defer fake.getInstanceSnapshotMutex.Unlock()
	fake.GetInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) GetInstanceSnapshotArgsForCall(i int) (string, string) {
	fake.getInstanceSnapshotMutex.RLock()
	defer fake.getInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.getInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceSnapshotReturns(result1 *api.InstanceSnapshot, result2 string, result3 error) {
	fake.getInstanceSnapshotMutex.Lock()
	defer fake.getInstanceSnapshotMutex.Unlock()
	fake.GetInstanceSnapshotStub = nil
	fake.getInstanceSnapshotReturns = struct {
		result1 *api.InstanceSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceSnapshotReturnsOnCall(i int, result1 *api.InstanceSnapshot, result2 string, result3 error) {
	fake.getInstanceSnapshotMutex.Lock()
	defer fake.getInstanceSnapshotMutex.Unlock()
	fake.GetInstanceSnapshotStub = nil
	if fake.getInstanceSnapshotReturnsOnCall == nil {
		fake.getInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 *api.InstanceSnapshot
			result2 string
			result3 error
		})
	}
	fake.getInstanceSnapshotReturnsOnCall[i] = struct {
		result1 *api.InstanceSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceSnapshotNames(arg1 string) ([]string, error) {
	fake.getInstanceSnapshotNamesMutex.Lock()
	ret, specificReturn := fake.getInstanceSnapshotNamesReturnsOnCall[len(fake.getInstanceSnapshotNamesArgsForCall)]
	fake.getInstanceSnapshotNamesArgsForCall = append(fake.getInstanceSnapshotNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceSnapshotNamesStub
	fakeReturns := fake.getInstanceSnapshotNamesReturns
	fake.recordInvocation("GetInstanceSnapshotNames", []interface{}{arg1})
	fake.getInstanceSnapshotNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceSnapshotNamesCallCount() int {
	fake.getInstanceSnapshotNamesMutex.RLock()
	defer fake.getInstanceSnapshotNamesMutex.RUnlock()
	return len(fake.getInstanceSnapshotNamesArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceSnapshotNamesCalls(stub func(string) ([]string, error)) {
	fake.getInstanceSnapshotNamesMutex.Lock()
	defer fake.getInstanceSnapshotNamesMutex.Unlock()
	fake.GetInstanceSnapshotNamesStub = stub
}

func (fake *FakeContainerServer) GetInstanceSnapshotNamesArgsForCall(i int) string {
	fake.getInstanceSnapshotNamesMutex.RLock()
	defer fake.getInstanceSnapshotNamesMutex.RUnlock()
	argsForCall := fake.getInstanceSnapshotNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceSnapshotNamesReturns(result1 []string, result2 error) {
	fake.getInstanceSnapshotNamesMutex.Lock()
	defer fake.getInstanceSnapshotNamesMutex.Unlock()
	fake.GetInstanceSnapshotNamesStub = nil
	fake.getInstanceSnapshotNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceSnapshotNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getInstanceSnapshotNamesMutex.Lock()
	defer fake.getInstanceSnapshotNamesMutex.Unlock()
	fake.GetInstanceSnapshotNamesStub = nil
	if fake.getInstanceSnapshotNamesReturnsOnCall == nil {
		fake.getInstanceSnapshotNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getInstanceSnapshotNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceSnapshots(arg1 string) ([]api.InstanceSnapshot, error) {
	fake.getInstanceSnapshotsMutex.Lock()
	ret, specificReturn := fake.getInstanceSnapshotsReturnsOnCall[len(fake.getInstanceSnapshotsArgsForCall)]
	fake.getInstanceSnapshotsArgsForCall = append(fake.getInstanceSnapshotsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceSnapshotsStub
	fakeReturns := fake.getInstanceSnapshotsReturns
	fake.recordInvocation("GetInstanceSnapshots", []interface{}{arg1})
	fake.getInstanceSnapshotsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceSnapshotsCallCount() int {
	fake.getInstanceSnapshotsMutex.RLock()
	defer fake.getInstanceSnapshotsMutex.RUnlock()
	return len(fake.getInstanceSnapshotsArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceSnapshotsCalls(stub func(string) ([]api.InstanceSnapshot, error)) {
	fake.getInstanceSnapshotsMutex.Lock()
	defer fake.getInstanceSnapshotsMutex.Unlock()
	fake.GetInstanceSnapshotsStub = stub
}

func (fake *FakeContainerServer) GetInstanceSnapshotsArgsForCall(i int) string {
	fake.getInstanceSnapshotsMutex.RLock()
	defer fake.getInstanceSnapshotsMutex.RUnlock()
	argsForCall := fake.getInstanceSnapshotsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceSnapshotsReturns(result1 []api.InstanceSnapshot, result2 error) {
	fake.getInstanceSnapshotsMutex.Lock()
	defer fake.getInstanceSnapshotsMutex.Unlock()
	fake.GetInstanceSnapshotsStub = nil
	fake.getInstanceSnapshotsReturns = struct {
		result1 []api.InstanceSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceSnapshotsReturnsOnCall(i int, result1 []api.InstanceSnapshot, result2 error) {
	fake.getInstanceSnapshotsMutex.Lock()
	defer fake.getInstanceSnapshotsMutex.Unlock()
	fake.GetInstanceSnapshotsStub = nil
	if fake.getInstanceSnapshotsReturnsOnCall == nil {
		fake.getInstanceSnapshotsReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceSnapshot
			result2 error
		})
	}
	fake.getInstanceSnapshotsReturnsOnCall[i] = struct {
		result1 []api.InstanceSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceState(arg1 string) (*api.InstanceState, string, error) {
	fake.getInstanceStateMutex.Lock()
	ret, specificReturn := fake.getInstanceStateReturnsOnCall[len(fake.getInstanceStateArgsForCall)]
	fake.getInstanceStateArgsForCall = append(fake.getInstanceStateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceStateStub
	fakeReturns := fake.getInstanceStateReturns
	fake.recordInvocation("GetInstanceState", []interface{}{arg1})
	fake.getInstanceStateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetInstanceStateCallCount() int {
	fake.getInstanceStateMutex.RLock()
	defer fake.getInstanceStateMutex.RUnlock()
	return len(fake.getInstanceStateArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceStateCalls(stub func(string) (*api.InstanceState, string, error)) {
	fake.getInstanceStateMutex.Lock()
	defer fake.getInstanceStateMutex.Unlock()
	fake.GetInstanceStateStub = stub
}

func (fake *FakeContainerServer) GetInstanceStateArgsForCall(i int) string {
	fake.getInstanceStateMutex.RLock()
	defer fake.getInstanceStateMutex.RUnlock()
	argsForCall := fake.getInstanceStateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceStateReturns(result1 *api.InstanceState, result2 string, result3 error) {
	fake.getInstanceStateMutex.Lock()
	defer fake.getInstanceStateMutex.Unlock()
	fake.GetInstanceStateStub = nil
	fake.getInstanceStateReturns = struct {
		result1 *api.InstanceState
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceStateReturnsOnCall(i int, result1 *api.InstanceState, result2 string, result3 error) {
	fake.getInstanceStateMutex.Lock()
	defer fake.getInstanceStateMutex.Unlock()
	fake.GetInstanceStateStub = nil
	if fake.getInstanceStateReturnsOnCall == nil {
		fake.getInstanceStateReturnsOnCall = make(map[int]struct {
			result1 *api.InstanceState
			result2 string
			result3 error
		})
	}
	fake.getInstanceStateReturnsOnCall[i] = struct {
		result1 *api.InstanceState
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetInstanceTemplateFile(arg1 string, arg2 string) (io.ReadCloser, error) {
	fake.getInstanceTemplateFileMutex.Lock()
	ret, specificReturn := fake.getInstanceTemplateFileReturnsOnCall[len(fake.getInstanceTemplateFileArgsForCall)]
	fake.getInstanceTemplateFileArgsForCall = append(fake.getInstanceTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetInstanceTemplateFileStub
	fakeReturns := fake.getInstanceTemplateFileReturns
	fake.recordInvocation("GetInstanceTemplateFile", []interface{}{arg1, arg2})
	fake.getInstanceTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceTemplateFileCallCount() int {
	fake.getInstanceTemplateFileMutex.RLock()
	defer fake.getInstanceTemplateFileMutex.RUnlock()
	return len(fake.getInstanceTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceTemplateFileCalls(stub func(string, string) (io.ReadCloser, error)) {
	fake.getInstanceTemplateFileMutex.Lock()
	defer fake.getInstanceTemplateFileMutex.Unlock()
	fake.GetInstanceTemplateFileStub = stub
}

func (fake *FakeContainerServer) GetInstanceTemplateFileArgsForCall(i int) (string, string) {
	fake.getInstanceTemplateFileMutex.RLock()
	defer fake.getInstanceTemplateFileMutex.RUnlock()
	argsForCall := fake.getInstanceTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstanceTemplateFileReturns(result1 io.ReadCloser, result2 error) {
	fake.getInstanceTemplateFileMutex.Lock()
	defer fake.getInstanceTemplateFileMutex.Unlock()
	fake.GetInstanceTemplateFileStub = nil
	fake.getInstanceTemplateFileReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceTemplateFileReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getInstanceTemplateFileMutex.Lock()
	defer fake.getInstanceTemplateFileMutex.Unlock()
	fake.GetInstanceTemplateFileStub = nil
	if fake.getInstanceTemplateFileReturnsOnCall == nil {
		fake.getInstanceTemplateFileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getInstanceTemplateFileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceTemplateFiles(arg1 string) ([]string, error) {
	fake.getInstanceTemplateFilesMutex.Lock()
	ret, specificReturn := fake.getInstanceTemplateFilesReturnsOnCall[len(fake.getInstanceTemplateFilesArgsForCall)]
	fake.getInstanceTemplateFilesArgsForCall = append(fake.getInstanceTemplateFilesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetInstanceTemplateFilesStub
	fakeReturns := fake.getInstanceTemplateFilesReturns
	fake.recordInvocation("GetInstanceTemplateFiles", []interface{}{arg1})
	fake.getInstanceTemplateFilesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstanceTemplateFilesCallCount() int {
	fake.getInstanceTemplateFilesMutex.RLock()
	defer fake.getInstanceTemplateFilesMutex.RUnlock()
	return len(fake.getInstanceTemplateFilesArgsForCall)
}

func (fake *FakeContainerServer) GetInstanceTemplateFilesCalls(stub func(string) ([]string, error)) {
	fake.getInstanceTemplateFilesMutex.Lock()
	defer fake.getInstanceTemplateFilesMutex.Unlock()
	fake.GetInstanceTemplateFilesStub = stub
}

func (fake *FakeContainerServer) GetInstanceTemplateFilesArgsForCall(i int) string {
	fake.getInstanceTemplateFilesMutex.RLock()
	defer fake.getInstanceTemplateFilesMutex.RUnlock()
	argsForCall := fake.getInstanceTemplateFilesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstanceTemplateFilesReturns(result1 []string, result2 error) {
	fake.getInstanceTemplateFilesMutex.Lock()
	defer fake.getInstanceTemplateFilesMutex.Unlock()
	fake.GetInstanceTemplateFilesStub = nil
	fake.getInstanceTemplateFilesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstanceTemplateFilesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getInstanceTemplateFilesMutex.Lock()
	defer fake.getInstanceTemplateFilesMutex.Unlock()
	fake.GetInstanceTemplateFilesStub = nil
	if fake.getInstanceTemplateFilesReturnsOnCall == nil {
		fake.getInstanceTemplateFilesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getInstanceTemplateFilesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstances(arg1 api.InstanceType) ([]api.Instance, error) {
	fake.getInstancesMutex.Lock()
	ret, specificReturn := fake.getInstancesReturnsOnCall[len(fake.getInstancesArgsForCall)]
	fake.getInstancesArgsForCall = append(fake.getInstancesArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstancesStub
	fakeReturns := fake.getInstancesReturns
	fake.recordInvocation("GetInstances", []interface{}{arg1})
	fake.getInstancesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesCallCount() int {
	fake.getInstancesMutex.RLock()
	defer fake.getInstancesMutex.RUnlock()
	return len(fake.getInstancesArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesCalls(stub func(api.InstanceType) ([]api.Instance, error)) {
	fake.getInstancesMutex.Lock()
	defer fake.getInstancesMutex.Unlock()
	fake.GetInstancesStub = stub
}

func (fake *FakeContainerServer) GetInstancesArgsForCall(i int) api.InstanceType {
	fake.getInstancesMutex.RLock()
	defer fake.getInstancesMutex.RUnlock()
	argsForCall := fake.getInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstancesReturns(result1 []api.Instance, result2 error) {
	fake.getInstancesMutex.Lock()
	defer fake.getInstancesMutex.Unlock()
	fake.GetInstancesStub = nil
	fake.getInstancesReturns = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesReturnsOnCall(i int, result1 []api.Instance, result2 error) {
	fake.getInstancesMutex.Lock()
	defer fake.getInstancesMutex.Unlock()
	fake.GetInstancesStub = nil
	if fake.getInstancesReturnsOnCall == nil {
		fake.getInstancesReturnsOnCall = make(map[int]struct {
			result1 []api.Instance
			result2 error
		})
	}
	fake.getInstancesReturnsOnCall[i] = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesAllProjects(arg1 api.InstanceType) ([]api.Instance, error) {
	fake.getInstancesAllProjectsMutex.Lock()
	ret, specificReturn := fake.getInstancesAllProjectsReturnsOnCall[len(fake.getInstancesAllProjectsArgsForCall)]
	fake.getInstancesAllProjectsArgsForCall = append(fake.getInstancesAllProjectsArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstancesAllProjectsStub
	fakeReturns := fake.getInstancesAllProjectsReturns
	fake.recordInvocation("GetInstancesAllProjects", []interface{}{arg1})
	fake.getInstancesAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesAllProjectsCallCount() int {
	fake.getInstancesAllProjectsMutex.RLock()
	defer fake.getInstancesAllProjectsMutex.RUnlock()
	return len(fake.getInstancesAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesAllProjectsCalls(stub func(api.InstanceType) ([]api.Instance, error)) {
	fake.getInstancesAllProjectsMutex.Lock()
	defer fake.getInstancesAllProjectsMutex.Unlock()
	fake.GetInstancesAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetInstancesAllProjectsArgsForCall(i int) api.InstanceType {
	fake.getInstancesAllProjectsMutex.RLock()
	defer fake.getInstancesAllProjectsMutex.RUnlock()
	argsForCall := fake.getInstancesAllProjectsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstancesAllProjectsReturns(result1 []api.Instance, result2 error) {
	fake.getInstancesAllProjectsMutex.Lock()
	defer fake.getInstancesAllProjectsMutex.Unlock()
	fake.GetInstancesAllProjectsStub = nil
	fake.getInstancesAllProjectsReturns = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesAllProjectsReturnsOnCall(i int, result1 []api.Instance, result2 error) {
	fake.getInstancesAllProjectsMutex.Lock()
	defer fake.getInstancesAllProjectsMutex.Unlock()
	fake.GetInstancesAllProjectsStub = nil
	if fake.getInstancesAllProjectsReturnsOnCall == nil {
		fake.getInstancesAllProjectsReturnsOnCall = make(map[int]struct {
			result1 []api.Instance
			result2 error
		})
	}
	fake.getInstancesAllProjectsReturnsOnCall[i] = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilter(arg1 api.InstanceType, arg2 []string) ([]api.Instance, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getInstancesAllProjectsWithFilterMutex.Lock()
	ret, specificReturn := fake.getInstancesAllProjectsWithFilterReturnsOnCall[len(fake.getInstancesAllProjectsWithFilterArgsForCall)]
	fake.getInstancesAllProjectsWithFilterArgsForCall = append(fake.getInstancesAllProjectsWithFilterArgsForCall, struct {
		arg1 api.InstanceType
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetInstancesAllProjectsWithFilterStub
	fakeReturns := fake.getInstancesAllProjectsWithFilterReturns
	fake.recordInvocation("GetInstancesAllProjectsWithFilter", []interface{}{arg1, arg2Copy})
	fake.getInstancesAllProjectsWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilterCallCount() int {
	fake.getInstancesAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesAllProjectsWithFilterMutex.RUnlock()
	return len(fake.getInstancesAllProjectsWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilterCalls(stub func(api.InstanceType, []string) ([]api.Instance, error)) {
	fake.getInstancesAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesAllProjectsWithFilterStub = stub
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilterArgsForCall(i int) (api.InstanceType, []string) {
	fake.getInstancesAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesAllProjectsWithFilterMutex.RUnlock()
	argsForCall := fake.getInstancesAllProjectsWithFilterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilterReturns(result1 []api.Instance, result2 error) {
	fake.getInstancesAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesAllProjectsWithFilterStub = nil
	fake.getInstancesAllProjectsWithFilterReturns = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesAllProjectsWithFilterReturnsOnCall(i int, result1 []api.Instance, result2 error) {
	fake.getInstancesAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesAllProjectsWithFilterStub = nil
	if fake.getInstancesAllProjectsWithFilterReturnsOnCall == nil {
		fake.getInstancesAllProjectsWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.Instance
			result2 error
		})
	}
	fake.getInstancesAllProjectsWithFilterReturnsOnCall[i] = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFull(arg1 api.InstanceType) ([]api.InstanceFull, error) {
	fake.getInstancesFullMutex.Lock()
	ret, specificReturn := fake.getInstancesFullReturnsOnCall[len(fake.getInstancesFullArgsForCall)]
	fake.getInstancesFullArgsForCall = append(fake.getInstancesFullArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstancesFullStub
	fakeReturns := fake.getInstancesFullReturns
	fake.recordInvocation("GetInstancesFull", []interface{}{arg1})
	fake.getInstancesFullMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesFullCallCount() int {
	fake.getInstancesFullMutex.RLock()
	defer fake.getInstancesFullMutex.RUnlock()
	return len(fake.getInstancesFullArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesFullCalls(stub func(api.InstanceType) ([]api.InstanceFull, error)) {
	fake.getInstancesFullMutex.Lock()
	defer fake.getInstancesFullMutex.Unlock()
	fake.GetInstancesFullStub = stub
}

func (fake *FakeContainerServer) GetInstancesFullArgsForCall(i int) api.InstanceType {
	fake.getInstancesFullMutex.RLock()
	defer fake.getInstancesFullMutex.RUnlock()
	argsForCall := fake.getInstancesFullArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstancesFullReturns(result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullMutex.Lock()
	defer fake.getInstancesFullMutex.Unlock()
	fake.GetInstancesFullStub = nil
	fake.getInstancesFullReturns = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullReturnsOnCall(i int, result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullMutex.Lock()
	defer fake.getInstancesFullMutex.Unlock()
	fake.GetInstancesFullStub = nil
	if fake.getInstancesFullReturnsOnCall == nil {
		fake.getInstancesFullReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceFull
			result2 error
		})
	}
	fake.getInstancesFullReturnsOnCall[i] = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullAllProjects(arg1 api.InstanceType) ([]api.InstanceFull, error) {
	fake.getInstancesFullAllProjectsMutex.Lock()
	ret, specificReturn := fake.getInstancesFullAllProjectsReturnsOnCall[len(fake.getInstancesFullAllProjectsArgsForCall)]
	fake.getInstancesFullAllProjectsArgsForCall = append(fake.getInstancesFullAllProjectsArgsForCall, struct {
		arg1 api.InstanceType
	}{arg1})
	stub := fake.GetInstancesFullAllProjectsStub
	fakeReturns := fake.getInstancesFullAllProjectsReturns
	fake.recordInvocation("GetInstancesFullAllProjects", []interface{}{arg1})
	fake.getInstancesFullAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsCallCount() int {
	fake.getInstancesFullAllProjectsMutex.RLock()
	defer fake.getInstancesFullAllProjectsMutex.RUnlock()
	return len(fake.getInstancesFullAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsCalls(stub func(api.InstanceType) ([]api.InstanceFull, error)) {
	fake.getInstancesFullAllProjectsMutex.Lock()
	defer fake.getInstancesFullAllProjectsMutex.Unlock()
	fake.GetInstancesFullAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsArgsForCall(i int) api.InstanceType {
	fake.getInstancesFullAllProjectsMutex.RLock()
	defer fake.getInstancesFullAllProjectsMutex.RUnlock()
	argsForCall := fake.getInstancesFullAllProjectsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsReturns(result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullAllProjectsMutex.Lock()
	defer fake.getInstancesFullAllProjectsMutex.Unlock()
	fake.GetInstancesFullAllProjectsStub = nil
	fake.getInstancesFullAllProjectsReturns = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsReturnsOnCall(i int, result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullAllProjectsMutex.Lock()
	defer fake.getInstancesFullAllProjectsMutex.Unlock()
	fake.GetInstancesFullAllProjectsStub = nil
	if fake.getInstancesFullAllProjectsReturnsOnCall == nil {
		fake.getInstancesFullAllProjectsReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceFull
			result2 error
		})
	}
	fake.getInstancesFullAllProjectsReturnsOnCall[i] = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilter(arg1 api.InstanceType, arg2 []string) ([]api.InstanceFull, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getInstancesFullAllProjectsWithFilterMutex.Lock()
	ret, specificReturn := fake.getInstancesFullAllProjectsWithFilterReturnsOnCall[len(fake.getInstancesFullAllProjectsWithFilterArgsForCall)]
	fake.getInstancesFullAllProjectsWithFilterArgsForCall = append(fake.getInstancesFullAllProjectsWithFilterArgsForCall, struct {
		arg1 api.InstanceType
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetInstancesFullAllProjectsWithFilterStub
	fakeReturns := fake.getInstancesFullAllProjectsWithFilterReturns
	fake.recordInvocation("GetInstancesFullAllProjectsWithFilter", []interface{}{arg1, arg2Copy})
	fake.getInstancesFullAllProjectsWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilterCallCount() int {
	fake.getInstancesFullAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.RUnlock()
	return len(fake.getInstancesFullAllProjectsWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilterCalls(stub func(api.InstanceType, []string) ([]api.InstanceFull, error)) {
	fake.getInstancesFullAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesFullAllProjectsWithFilterStub = stub
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilterArgsForCall(i int) (api.InstanceType, []string) {
	fake.getInstancesFullAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.RUnlock()
	argsForCall := fake.getInstancesFullAllProjectsWithFilterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilterReturns(result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesFullAllProjectsWithFilterStub = nil
	fake.getInstancesFullAllProjectsWithFilterReturns = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullAllProjectsWithFilterReturnsOnCall(i int, result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullAllProjectsWithFilterMutex.Lock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.Unlock()
	fake.GetInstancesFullAllProjectsWithFilterStub = nil
	if fake.getInstancesFullAllProjectsWithFilterReturnsOnCall == nil {
		fake.getInstancesFullAllProjectsWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceFull
			result2 error
		})
	}
	fake.getInstancesFullAllProjectsWithFilterReturnsOnCall[i] = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullWithFilter(arg1 api.InstanceType, arg2 []string) ([]api.InstanceFull, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getInstancesFullWithFilterMutex.Lock()
	ret, specificReturn := fake.getInstancesFullWithFilterReturnsOnCall[len(fake.getInstancesFullWithFilterArgsForCall)]
	fake.getInstancesFullWithFilterArgsForCall = append(fake.getInstancesFullWithFilterArgsForCall, struct {
		arg1 api.InstanceType
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetInstancesFullWithFilterStub
	fakeReturns := fake.getInstancesFullWithFilterReturns
	fake.recordInvocation("GetInstancesFullWithFilter", []interface{}{arg1, arg2Copy})
	fake.getInstancesFullWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesFullWithFilterCallCount() int {
	fake.getInstancesFullWithFilterMutex.RLock()
	defer fake.getInstancesFullWithFilterMutex.RUnlock()
	return len(fake.getInstancesFullWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesFullWithFilterCalls(stub func(api.InstanceType, []string) ([]api.InstanceFull, error)) {
	fake.getInstancesFullWithFilterMutex.Lock()
	defer fake.getInstancesFullWithFilterMutex.Unlock()
	fake.GetInstancesFullWithFilterStub = stub
}

func (fake *FakeContainerServer) GetInstancesFullWithFilterArgsForCall(i int) (api.InstanceType, []string) {
	fake.getInstancesFullWithFilterMutex.RLock()
	defer fake.getInstancesFullWithFilterMutex.RUnlock()
	argsForCall := fake.getInstancesFullWithFilterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstancesFullWithFilterReturns(result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullWithFilterMutex.Lock()
	defer fake.getInstancesFullWithFilterMutex.Unlock()
	fake.GetInstancesFullWithFilterStub = nil
	fake.getInstancesFullWithFilterReturns = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesFullWithFilterReturnsOnCall(i int, result1 []api.InstanceFull, result2 error) {
	fake.getInstancesFullWithFilterMutex.Lock()
	defer fake.getInstancesFullWithFilterMutex.Unlock()
	fake.GetInstancesFullWithFilterStub = nil
	if fake.getInstancesFullWithFilterReturnsOnCall == nil {
		fake.getInstancesFullWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.InstanceFull
			result2 error
		})
	}
	fake.getInstancesFullWithFilterReturnsOnCall[i] = struct {
		result1 []api.InstanceFull
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesWithFilter(arg1 api.InstanceType, arg2 []string) ([]api.Instance, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getInstancesWithFilterMutex.Lock()
	ret, specificReturn := fake.getInstancesWithFilterReturnsOnCall[len(fake.getInstancesWithFilterArgsForCall)]
	fake.getInstancesWithFilterArgsForCall = append(fake.getInstancesWithFilterArgsForCall, struct {
		arg1 api.InstanceType
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetInstancesWithFilterStub
	fakeReturns := fake.getInstancesWithFilterReturns
	fake.recordInvocation("GetInstancesWithFilter", []interface{}{arg1, arg2Copy})
	fake.getInstancesWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetInstancesWithFilterCallCount() int {
	fake.getInstancesWithFilterMutex.RLock()
	defer fake.getInstancesWithFilterMutex.RUnlock()
	return len(fake.getInstancesWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetInstancesWithFilterCalls(stub func(api.InstanceType, []string) ([]api.Instance, error)) {
	fake.getInstancesWithFilterMutex.Lock()
	defer fake.getInstancesWithFilterMutex.Unlock()
	fake.GetInstancesWithFilterStub = stub
}

func (fake *FakeContainerServer) GetInstancesWithFilterArgsForCall(i int) (api.InstanceType, []string) {
	fake.getInstancesWithFilterMutex.RLock()
	defer fake.getInstancesWithFilterMutex.RUnlock()
	argsForCall := fake.getInstancesWithFilterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetInstancesWithFilterReturns(result1 []api.Instance, result2 error) {
	fake.getInstancesWithFilterMutex.Lock()
	defer fake.getInstancesWithFilterMutex.Unlock()
	fake.GetInstancesWithFilterStub = nil
	fake.getInstancesWithFilterReturns = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetInstancesWithFilterReturnsOnCall(i int, result1 []api.Instance, result2 error) {
	fake.getInstancesWithFilterMutex.Lock()
	defer fake.getInstancesWithFilterMutex.Unlock()
	fake.GetInstancesWithFilterStub = nil
	if fake.getInstancesWithFilterReturnsOnCall == nil {
		fake.getInstancesWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.Instance
			result2 error
		})
	}
	fake.getInstancesWithFilterReturnsOnCall[i] = struct {
		result1 []api.Instance
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetMetrics() (string, error) {
	fake.getMetricsMutex.Lock()
	ret, specificReturn := fake.getMetricsReturnsOnCall[len(fake.getMetricsArgsForCall)]
	fake.getMetricsArgsForCall = append(fake.getMetricsArgsForCall, struct {
	}{})
	stub := fake.GetMetricsStub
	fakeReturns := fake.getMetricsReturns
	fake.recordInvocation("GetMetrics", []interface{}{})
	fake.getMetricsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetMetricsCallCount() int {
	fake.getMetricsMutex.RLock()
	defer fake.getMetricsMutex.RUnlock()
	return len(fake.getMetricsArgsForCall)
}

func (fake *FakeContainerServer) GetMetricsCalls(stub func() (string, error)) {
	fake.getMetricsMutex.Lock()
	defer fake.getMetricsMutex.Unlock()
	fake.GetMetricsStub = stub
}

func (fake *FakeContainerServer) GetMetricsReturns(result1 string, result2 error) {
	fake.getMetricsMutex.Lock()
	defer fake.getMetricsMutex.Unlock()
	fake.GetMetricsStub = nil
	fake.getMetricsReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetMetricsReturnsOnCall(i int, result1 string, result2 error) {
	fake.getMetricsMutex.Lock()
	defer fake.getMetricsMutex.Unlock()
	fake.GetMetricsStub = nil
	if fake.getMetricsReturnsOnCall == nil {
		fake.getMetricsReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getMetricsReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetwork(arg1 string) (*api.Network, string, error) {
	fake.getNetworkMutex.Lock()
	ret, specificReturn := fake.getNetworkReturnsOnCall[len(fake.getNetworkArgsForCall)]
	fake.getNetworkArgsForCall = append(fake.getNetworkArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkStub
	fakeReturns := fake.getNetworkReturns
	fake.recordInvocation("GetNetwork", []interface{}{arg1})
	fake.getNetworkMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkCallCount() int {
	fake.getNetworkMutex.RLock()
	defer fake.getNetworkMutex.RUnlock()
	return len(fake.getNetworkArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkCalls(stub func(string) (*api.Network, string, error)) {
	fake.getNetworkMutex.Lock()
	defer fake.getNetworkMutex.Unlock()
	fake.GetNetworkStub = stub
}

func (fake *FakeContainerServer) GetNetworkArgsForCall(i int) string {
	fake.getNetworkMutex.RLock()
	defer fake.getNetworkMutex.RUnlock()
	argsForCall := fake.getNetworkArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkReturns(result1 *api.Network, result2 string, result3 error) {
	fake.getNetworkMutex.Lock()
	defer fake.getNetworkMutex.Unlock()
	fake.GetNetworkStub = nil
	fake.getNetworkReturns = struct {
		result1 *api.Network
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkReturnsOnCall(i int, result1 *api.Network, result2 string, result3 error) {
	fake.getNetworkMutex.Lock()
	defer fake.getNetworkMutex.Unlock()
	fake.GetNetworkStub = nil
	if fake.getNetworkReturnsOnCall == nil {
		fake.getNetworkReturnsOnCall = make(map[int]struct {
			result1 *api.Network
			result2 string
			result3 error
		})
	}
	fake.getNetworkReturnsOnCall[i] = struct {
		result1 *api.Network
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkACL(arg1 string) (*api.NetworkACL, string, error) {
	fake.getNetworkACLMutex.Lock()
	ret, specificReturn := fake.getNetworkACLReturnsOnCall[len(fake.getNetworkACLArgsForCall)]
	fake.getNetworkACLArgsForCall = append(fake.getNetworkACLArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkACLStub
	fakeReturns := fake.getNetworkACLReturns
	fake.recordInvocation("GetNetworkACL", []interface{}{arg1})
	fake.getNetworkACLMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkACLCallCount() int {
	fake.getNetworkACLMutex.RLock()
	defer fake.getNetworkACLMutex.RUnlock()
	return len(fake.getNetworkACLArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkACLCalls(stub func(string) (*api.NetworkACL, string, error)) {
	fake.getNetworkACLMutex.Lock()
	defer fake.getNetworkACLMutex.Unlock()
	fake.GetNetworkACLStub = stub
}

func (fake *FakeContainerServer) GetNetworkACLArgsForCall(i int) string {
	fake.getNetworkACLMutex.RLock()
	defer fake.getNetworkACLMutex.RUnlock()
	argsForCall := fake.getNetworkACLArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkACLReturns(result1 *api.NetworkACL, result2 string, result3 error) {
	fake.getNetworkACLMutex.Lock()
	defer fake.getNetworkACLMutex.Unlock()
	fake.GetNetworkACLStub = nil
	fake.getNetworkACLReturns = struct {
		result1 *api.NetworkACL
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkACLReturnsOnCall(i int, result1 *api.NetworkACL, result2 string, result3 error) {
	fake.getNetworkACLMutex.Lock()
	defer fake.getNetworkACLMutex.Unlock()
	fake.GetNetworkACLStub = nil
	if fake.getNetworkACLReturnsOnCall == nil {
		fake.getNetworkACLReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkACL
			result2 string
			result3 error
		})
	}
	fake.getNetworkACLReturnsOnCall[i] = struct {
		result1 *api.NetworkACL
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkACLLogfile(arg1 string) (io.ReadCloser, error) {
	fake.getNetworkACLLogfileMutex.Lock()
	ret, specificReturn := fake.getNetworkACLLogfileReturnsOnCall[len(fake.getNetworkACLLogfileArgsForCall)]
	fake.getNetworkACLLogfileArgsForCall = append(fake.getNetworkACLLogfileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkACLLogfileStub
	fakeReturns := fake.getNetworkACLLogfileReturns
	fake.recordInvocation("GetNetworkACLLogfile", []interface{}{arg1})
	fake.getNetworkACLLogfileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkACLLogfileCallCount() int {
	fake.getNetworkACLLogfileMutex.RLock()
	defer fake.getNetworkACLLogfileMutex.RUnlock()
	return len(fake.getNetworkACLLogfileArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkACLLogfileCalls(stub func(string) (io.ReadCloser, error)) {
	fake.getNetworkACLLogfileMutex.Lock()
	defer fake.getNetworkACLLogfileMutex.Unlock()
	fake.GetNetworkACLLogfileStub = stub
}

func (fake *FakeContainerServer) GetNetworkACLLogfileArgsForCall(i int) string {
	fake.getNetworkACLLogfileMutex.RLock()
	defer fake.getNetworkACLLogfileMutex.RUnlock()
	argsForCall := fake.getNetworkACLLogfileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkACLLogfileReturns(result1 io.ReadCloser, result2 error) {
	fake.getNetworkACLLogfileMutex.Lock()
	defer fake.getNetworkACLLogfileMutex.Unlock()
	fake.GetNetworkACLLogfileStub = nil
	fake.getNetworkACLLogfileReturns = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkACLLogfileReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
	fake.getNetworkACLLogfileMutex.Lock()
	defer fake.getNetworkACLLogfileMutex.Unlock()
	fake.GetNetworkACLLogfileStub = nil
	if fake.getNetworkACLLogfileReturnsOnCall == nil {
		fake.getNetworkACLLogfileReturnsOnCall = make(map[int]struct {
			result1 io.ReadCloser
			result2 error
		})
	}
	fake.getNetworkACLLogfileReturnsOnCall[i] = struct {
		result1 io.ReadCloser
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkACLNames() ([]string, error) {
	fake.getNetworkACLNamesMutex.Lock()
	ret, specificReturn := fake.getNetworkACLNamesReturnsOnCall[len(fake.getNetworkACLNamesArgsForCall)]
	fake.getNetworkACLNamesArgsForCall = append(fake.getNetworkACLNamesArgsForCall, struct {
	}{})
	stub := fake.GetNetworkACLNamesStub
	fakeReturns := fake.getNetworkACLNamesReturns
	fake.recordInvocation("GetNetworkACLNames", []interface{}{})
	fake.getNetworkACLNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkACLNamesCallCount() int {
	fake.getNetworkACLNamesMutex.RLock()
	defer fake.getNetworkACLNamesMutex.RUnlock()
	return len(fake.getNetworkACLNamesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkACLNamesCalls(stub func() ([]string, error)) {
	fake.getNetworkACLNamesMutex.Lock()
	defer fake.getNetworkACLNamesMutex.Unlock()
	fake.GetNetworkACLNamesStub = stub
}

func (fake *FakeContainerServer) GetNetworkACLNamesReturns(result1 []string, result2 error) {
	fake.getNetworkACLNamesMutex.Lock()
	defer fake.getNetworkACLNamesMutex.Unlock()
	fake.GetNetworkACLNamesStub = nil
	fake.getNetworkACLNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkACLNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkACLNamesMutex.Lock()
	defer fake.getNetworkACLNamesMutex.Unlock()
	fake.GetNetworkACLNamesStub = nil
	if fake.getNetworkACLNamesReturnsOnCall == nil {
		fake.getNetworkACLNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkACLNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkACLs() ([]api.NetworkACL, error) {
	fake.getNetworkACLsMutex.Lock()
	ret, specificReturn := fake.getNetworkACLsReturnsOnCall[len(fake.getNetworkACLsArgsForCall)]
	fake.getNetworkACLsArgsForCall = append(fake.getNetworkACLsArgsForCall, struct {
	}{})
	stub := fake.GetNetworkACLsStub
	fakeReturns := fake.getNetworkACLsReturns
	fake.recordInvocation("GetNetworkACLs", []interface{}{})
	fake.getNetworkACLsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkACLsCallCount() int {
	fake.getNetworkACLsMutex.RLock()
	defer fake.getNetworkACLsMutex.RUnlock()
	return len(fake.getNetworkACLsArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkACLsCalls(stub func() ([]api.NetworkACL, error)) {
	fake.getNetworkACLsMutex.Lock()
	defer fake.getNetworkACLsMutex.Unlock()
	fake.GetNetworkACLsStub = stub
}

func (fake *FakeContainerServer) GetNetworkACLsReturns(result1 []api.NetworkACL, result2 error) {
	fake.getNetworkACLsMutex.Lock()
	defer fake.getNetworkACLsMutex.Unlock()
	fake.GetNetworkACLsStub = nil
	fake.getNetworkACLsReturns = struct {
		result1 []api.NetworkACL
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkACLsReturnsOnCall(i int, result1 []api.NetworkACL, result2 error) {
	fake.getNetworkACLsMutex.Lock()
	defer fake.getNetworkACLsMutex.Unlock()
	fake.GetNetworkACLsStub = nil
	if fake.getNetworkACLsReturnsOnCall == nil {
		fake.getNetworkACLsReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkACL
			result2 error
		})
	}
	fake.getNetworkACLsReturnsOnCall[i] = struct {
		result1 []api.NetworkACL
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkForward(arg1 string, arg2 string) (*api.NetworkForward, string, error) {
	fake.getNetworkForwardMutex.Lock()
	ret, specificReturn := fake.getNetworkForwardReturnsOnCall[len(fake.getNetworkForwardArgsForCall)]
	fake.getNetworkForwardArgsForCall = append(fake.getNetworkForwardArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetNetworkForwardStub
	fakeReturns := fake.getNetworkForwardReturns
	fake.recordInvocation("GetNetworkForward", []interface{}{arg1, arg2})
	fake.getNetworkForwardMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkForwardCallCount() int {
	fake.getNetworkForwardMutex.RLock()
	defer fake.getNetworkForwardMutex.RUnlock()
	return len(fake.getNetworkForwardArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkForwardCalls(stub func(string, string) (*api.NetworkForward, string, error)) {
	fake.getNetworkForwardMutex.Lock()
	defer fake.getNetworkForwardMutex.Unlock()
	fake.GetNetworkForwardStub = stub
}

func (fake *FakeContainerServer) GetNetworkForwardArgsForCall(i int) (string, string) {
	fake.getNetworkForwardMutex.RLock()
	defer fake.getNetworkForwardMutex.RUnlock()
	argsForCall := fake.getNetworkForwardArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetNetworkForwardReturns(result1 *api.NetworkForward, result2 string, result3 error) {
	fake.getNetworkForwardMutex.Lock()
	defer fake.getNetworkForwardMutex.Unlock()
	fake.GetNetworkForwardStub = nil
	fake.getNetworkForwardReturns = struct {
		result1 *api.NetworkForward
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkForwardReturnsOnCall(i int, result1 *api.NetworkForward, result2 string, result3 error) {
	fake.getNetworkForwardMutex.Lock()
	defer fake.getNetworkForwardMutex.Unlock()
	fake.GetNetworkForwardStub = nil
	if fake.getNetworkForwardReturnsOnCall == nil {
		fake.getNetworkForwardReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkForward
			result2 string
			result3 error
		})
	}
	fake.getNetworkForwardReturnsOnCall[i] = struct {
		result1 *api.NetworkForward
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkForwardAddresses(arg1 string) ([]string, error) {
	fake.getNetworkForwardAddressesMutex.Lock()
	ret, specificReturn := fake.getNetworkForwardAddressesReturnsOnCall[len(fake.getNetworkForwardAddressesArgsForCall)]
	fake.getNetworkForwardAddressesArgsForCall = append(fake.getNetworkForwardAddressesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkForwardAddressesStub
	fakeReturns := fake.getNetworkForwardAddressesReturns
	fake.recordInvocation("GetNetworkForwardAddresses", []interface{}{arg1})
	fake.getNetworkForwardAddressesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkForwardAddressesCallCount() int {
	fake.getNetworkForwardAddressesMutex.RLock()
	defer fake.getNetworkForwardAddressesMutex.RUnlock()
	return len(fake.getNetworkForwardAddressesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkForwardAddressesCalls(stub func(string) ([]string, error)) {
	fake.getNetworkForwardAddressesMutex.Lock()
	defer fake.getNetworkForwardAddressesMutex.Unlock()
	fake.GetNetworkForwardAddressesStub = stub
}

func (fake *FakeContainerServer) GetNetworkForwardAddressesArgsForCall(i int) string {
	fake.getNetworkForwardAddressesMutex.RLock()
	defer fake.getNetworkForwardAddressesMutex.RUnlock()
	argsForCall := fake.getNetworkForwardAddressesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkForwardAddressesReturns(result1 []string, result2 error) {
	fake.getNetworkForwardAddressesMutex.Lock()
	defer fake.getNetworkForwardAddressesMutex.Unlock()
	fake.GetNetworkForwardAddressesStub = nil
	fake.getNetworkForwardAddressesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkForwardAddressesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkForwardAddressesMutex.Lock()
	defer fake.getNetworkForwardAddressesMutex.Unlock()
	fake.GetNetworkForwardAddressesStub = nil
	if fake.getNetworkForwardAddressesReturnsOnCall == nil {
		fake.getNetworkForwardAddressesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkForwardAddressesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkForwards(arg1 string) ([]api.NetworkForward, error) {
	fake.getNetworkForwardsMutex.Lock()
	ret, specificReturn := fake.getNetworkForwardsReturnsOnCall[len(fake.getNetworkForwardsArgsForCall)]
	fake.getNetworkForwardsArgsForCall = append(fake.getNetworkForwardsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkForwardsStub
	fakeReturns := fake.getNetworkForwardsReturns
	fake.recordInvocation("GetNetworkForwards", []interface{}{arg1})
	fake.getNetworkForwardsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkForwardsCallCount() int {
	fake.getNetworkForwardsMutex.RLock()
	defer fake.getNetworkForwardsMutex.RUnlock()
	return len(fake.getNetworkForwardsArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkForwardsCalls(stub func(string) ([]api.NetworkForward, error)) {
	fake.getNetworkForwardsMutex.Lock()
	defer fake.getNetworkForwardsMutex.Unlock()
	fake.GetNetworkForwardsStub = stub
}

func (fake *FakeContainerServer) GetNetworkForwardsArgsForCall(i int) string {
	fake.getNetworkForwardsMutex.RLock()
	defer fake.getNetworkForwardsMutex.RUnlock()
	argsForCall := fake.getNetworkForwardsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkForwardsReturns(result1 []api.NetworkForward, result2 error) {
	fake.getNetworkForwardsMutex.Lock()
	defer fake.getNetworkForwardsMutex.Unlock()
	fake.GetNetworkForwardsStub = nil
	fake.getNetworkForwardsReturns = struct {
		result1 []api.NetworkForward
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkForwardsReturnsOnCall(i int, result1 []api.NetworkForward, result2 error) {
	fake.getNetworkForwardsMutex.Lock()
	defer fake.getNetworkForwardsMutex.Unlock()
	fake.GetNetworkForwardsStub = nil
	if fake.getNetworkForwardsReturnsOnCall == nil {
		fake.getNetworkForwardsReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkForward
			result2 error
		})
	}
	fake.getNetworkForwardsReturnsOnCall[i] = struct {
		result1 []api.NetworkForward
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLeases(arg1 string) ([]api.NetworkLease, error) {
	fake.getNetworkLeasesMutex.Lock()
	ret, specificReturn := fake.getNetworkLeasesReturnsOnCall[len(fake.getNetworkLeasesArgsForCall)]
	fake.getNetworkLeasesArgsForCall = append(fake.getNetworkLeasesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkLeasesStub
	fakeReturns := fake.getNetworkLeasesReturns
	fake.recordInvocation("GetNetworkLeases", []interface{}{arg1})
	fake.getNetworkLeasesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkLeasesCallCount() int {
	fake.getNetworkLeasesMutex.RLock()
	defer fake.getNetworkLeasesMutex.RUnlock()
	return len(fake.getNetworkLeasesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkLeasesCalls(stub func(string) ([]api.NetworkLease, error)) {
	fake.getNetworkLeasesMutex.Lock()
	defer fake.getNetworkLeasesMutex.Unlock()
	fake.GetNetworkLeasesStub = stub
}

func (fake *FakeContainerServer) GetNetworkLeasesArgsForCall(i int) string {
	fake.getNetworkLeasesMutex.RLock()
	defer fake.getNetworkLeasesMutex.RUnlock()
	argsForCall := fake.getNetworkLeasesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkLeasesReturns(result1 []api.NetworkLease, result2 error) {
	fake.getNetworkLeasesMutex.Lock()
	defer fake.getNetworkLeasesMutex.Unlock()
	fake.GetNetworkLeasesStub = nil
	fake.getNetworkLeasesReturns = struct {
		result1 []api.NetworkLease
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLeasesReturnsOnCall(i int, result1 []api.NetworkLease, result2 error) {
	fake.getNetworkLeasesMutex.Lock()
	defer fake.getNetworkLeasesMutex.Unlock()
	fake.GetNetworkLeasesStub = nil
	if fake.getNetworkLeasesReturnsOnCall == nil {
		fake.getNetworkLeasesReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkLease
			result2 error
		})
	}
	fake.getNetworkLeasesReturnsOnCall[i] = struct {
		result1 []api.NetworkLease
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancer(arg1 string, arg2 string) (*api.NetworkLoadBalancer, string, error) {
	fake.getNetworkLoadBalancerMutex.Lock()
	ret, specificReturn := fake.getNetworkLoadBalancerReturnsOnCall[len(fake.getNetworkLoadBalancerArgsForCall)]
	fake.getNetworkLoadBalancerArgsForCall = append(fake.getNetworkLoadBalancerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetNetworkLoadBalancerStub
	fakeReturns := fake.getNetworkLoadBalancerReturns
	fake.recordInvocation("GetNetworkLoadBalancer", []interface{}{arg1, arg2})
	fake.getNetworkLoadBalancerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerCallCount() int {
	fake.getNetworkLoadBalancerMutex.RLock()
	defer fake.getNetworkLoadBalancerMutex.RUnlock()
	return len(fake.getNetworkLoadBalancerArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerCalls(stub func(string, string) (*api.NetworkLoadBalancer, string, error)) {
	fake.getNetworkLoadBalancerMutex.Lock()
	defer fake.getNetworkLoadBalancerMutex.Unlock()
	fake.GetNetworkLoadBalancerStub = stub
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerArgsForCall(i int) (string, string) {
	fake.getNetworkLoadBalancerMutex.RLock()
	defer fake.getNetworkLoadBalancerMutex.RUnlock()
	argsForCall := fake.getNetworkLoadBalancerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerReturns(result1 *api.NetworkLoadBalancer, result2 string, result3 error) {
	fake.getNetworkLoadBalancerMutex.Lock()
	defer fake.getNetworkLoadBalancerMutex.Unlock()
	fake.GetNetworkLoadBalancerStub = nil
	fake.getNetworkLoadBalancerReturns = struct {
		result1 *api.NetworkLoadBalancer
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerReturnsOnCall(i int, result1 *api.NetworkLoadBalancer, result2 string, result3 error) {
	fake.getNetworkLoadBalancerMutex.Lock()
	defer fake.getNetworkLoadBalancerMutex.Unlock()
	fake.GetNetworkLoadBalancerStub = nil
	if fake.getNetworkLoadBalancerReturnsOnCall == nil {
		fake.getNetworkLoadBalancerReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkLoadBalancer
			result2 string
			result3 error
		})
	}
	fake.getNetworkLoadBalancerReturnsOnCall[i] = struct {
		result1 *api.NetworkLoadBalancer
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddresses(arg1 string) ([]string, error) {
	fake.getNetworkLoadBalancerAddressesMutex.Lock()
	ret, specificReturn := fake.getNetworkLoadBalancerAddressesReturnsOnCall[len(fake.getNetworkLoadBalancerAddressesArgsForCall)]
	fake.getNetworkLoadBalancerAddressesArgsForCall = append(fake.getNetworkLoadBalancerAddressesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkLoadBalancerAddressesStub
	fakeReturns := fake.getNetworkLoadBalancerAddressesReturns
	fake.recordInvocation("GetNetworkLoadBalancerAddresses", []interface{}{arg1})
	fake.getNetworkLoadBalancerAddressesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddressesCallCount() int {
	fake.getNetworkLoadBalancerAddressesMutex.RLock()
	defer fake.getNetworkLoadBalancerAddressesMutex.RUnlock()
	return len(fake.getNetworkLoadBalancerAddressesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddressesCalls(stub func(string) ([]string, error)) {
	fake.getNetworkLoadBalancerAddressesMutex.Lock()
	defer fake.getNetworkLoadBalancerAddressesMutex.Unlock()
	fake.GetNetworkLoadBalancerAddressesStub = stub
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddressesArgsForCall(i int) string {
	fake.getNetworkLoadBalancerAddressesMutex.RLock()
	defer fake.getNetworkLoadBalancerAddressesMutex.RUnlock()
	argsForCall := fake.getNetworkLoadBalancerAddressesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddressesReturns(result1 []string, result2 error) {
	fake.getNetworkLoadBalancerAddressesMutex.Lock()
	defer fake.getNetworkLoadBalancerAddressesMutex.Unlock()
	fake.GetNetworkLoadBalancerAddressesStub = nil
	fake.getNetworkLoadBalancerAddressesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancerAddressesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkLoadBalancerAddressesMutex.Lock()
	defer fake.getNetworkLoadBalancerAddressesMutex.Unlock()
	fake.GetNetworkLoadBalancerAddressesStub = nil
	if fake.getNetworkLoadBalancerAddressesReturnsOnCall == nil {
		fake.getNetworkLoadBalancerAddressesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkLoadBalancerAddressesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancers(arg1 string) ([]api.NetworkLoadBalancer, error) {
	fake.getNetworkLoadBalancersMutex.Lock()
	ret, specificReturn := fake.getNetworkLoadBalancersReturnsOnCall[len(fake.getNetworkLoadBalancersArgsForCall)]
	fake.getNetworkLoadBalancersArgsForCall = append(fake.getNetworkLoadBalancersArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkLoadBalancersStub
	fakeReturns := fake.getNetworkLoadBalancersReturns
	fake.recordInvocation("GetNetworkLoadBalancers", []interface{}{arg1})
	fake.getNetworkLoadBalancersMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkLoadBalancersCallCount() int {
	fake.getNetworkLoadBalancersMutex.RLock()
	defer fake.getNetworkLoadBalancersMutex.RUnlock()
	return len(fake.getNetworkLoadBalancersArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkLoadBalancersCalls(stub func(string) ([]api.NetworkLoadBalancer, error)) {
	fake.getNetworkLoadBalancersMutex.Lock()
	defer fake.getNetworkLoadBalancersMutex.Unlock()
	fake.GetNetworkLoadBalancersStub = stub
}

func (fake *FakeContainerServer) GetNetworkLoadBalancersArgsForCall(i int) string {
	fake.getNetworkLoadBalancersMutex.RLock()
	defer fake.getNetworkLoadBalancersMutex.RUnlock()
	argsForCall := fake.getNetworkLoadBalancersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkLoadBalancersReturns(result1 []api.NetworkLoadBalancer, result2 error) {
	fake.getNetworkLoadBalancersMutex.Lock()
	defer fake.getNetworkLoadBalancersMutex.Unlock()
	fake.GetNetworkLoadBalancersStub = nil
	fake.getNetworkLoadBalancersReturns = struct {
		result1 []api.NetworkLoadBalancer
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkLoadBalancersReturnsOnCall(i int, result1 []api.NetworkLoadBalancer, result2 error) {
	fake.getNetworkLoadBalancersMutex.Lock()
	defer fake.getNetworkLoadBalancersMutex.Unlock()
	fake.GetNetworkLoadBalancersStub = nil
	if fake.getNetworkLoadBalancersReturnsOnCall == nil {
		fake.getNetworkLoadBalancersReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkLoadBalancer
			result2 error
		})
	}
	fake.getNetworkLoadBalancersReturnsOnCall[i] = struct {
		result1 []api.NetworkLoadBalancer
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkNames() ([]string, error) {
	fake.getNetworkNamesMutex.Lock()
	ret, specificReturn := fake.getNetworkNamesReturnsOnCall[len(fake.getNetworkNamesArgsForCall)]
	fake.getNetworkNamesArgsForCall = append(fake.getNetworkNamesArgsForCall, struct {
	}{})
	stub := fake.GetNetworkNamesStub
	fakeReturns := fake.getNetworkNamesReturns
	fake.recordInvocation("GetNetworkNames", []interface{}{})
	fake.getNetworkNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkNamesCallCount() int {
	fake.getNetworkNamesMutex.RLock()
	defer fake.getNetworkNamesMutex.RUnlock()
	return len(fake.getNetworkNamesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkNamesCalls(stub func() ([]string, error)) {
	fake.getNetworkNamesMutex.Lock()
	defer fake.getNetworkNamesMutex.Unlock()
	fake.GetNetworkNamesStub = stub
}

func (fake *FakeContainerServer) GetNetworkNamesReturns(result1 []string, result2 error) {
	fake.getNetworkNamesMutex.Lock()
	defer fake.getNetworkNamesMutex.Unlock()
	fake.GetNetworkNamesStub = nil
	fake.getNetworkNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkNamesMutex.Lock()
	defer fake.getNetworkNamesMutex.Unlock()
	fake.GetNetworkNamesStub = nil
	if fake.getNetworkNamesReturnsOnCall == nil {
		fake.getNetworkNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkPeer(arg1 string, arg2 string) (*api.NetworkPeer, string, error) {
	fake.getNetworkPeerMutex.Lock()
	ret, specificReturn := fake.getNetworkPeerReturnsOnCall[len(fake.getNetworkPeerArgsForCall)]
	fake.getNetworkPeerArgsForCall = append(fake.getNetworkPeerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetNetworkPeerStub
	fakeReturns := fake.getNetworkPeerReturns
	fake.recordInvocation("GetNetworkPeer", []interface{}{arg1, arg2})
	fake.getNetworkPeerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkPeerCallCount() int {
	fake.getNetworkPeerMutex.RLock()
	defer fake.getNetworkPeerMutex.RUnlock()
	return len(fake.getNetworkPeerArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkPeerCalls(stub func(string, string) (*api.NetworkPeer, string, error)) {
	fake.getNetworkPeerMutex.Lock()
	defer fake.getNetworkPeerMutex.Unlock()
	fake.GetNetworkPeerStub = stub
}

func (fake *FakeContainerServer) GetNetworkPeerArgsForCall(i int) (string, string) {
	fake.getNetworkPeerMutex.RLock()
	defer fake.getNetworkPeerMutex.RUnlock()
	argsForCall := fake.getNetworkPeerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetNetworkPeerReturns(result1 *api.NetworkPeer, result2 string, result3 error) {
	fake.getNetworkPeerMutex.Lock()
	defer fake.getNetworkPeerMutex.Unlock()
	fake.GetNetworkPeerStub = nil
	fake.getNetworkPeerReturns = struct {
		result1 *api.NetworkPeer
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkPeerReturnsOnCall(i int, result1 *api.NetworkPeer, result2 string, result3 error) {
	fake.getNetworkPeerMutex.Lock()
	defer fake.getNetworkPeerMutex.Unlock()
	fake.GetNetworkPeerStub = nil
	if fake.getNetworkPeerReturnsOnCall == nil {
		fake.getNetworkPeerReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkPeer
			result2 string
			result3 error
		})
	}
	fake.getNetworkPeerReturnsOnCall[i] = struct {
		result1 *api.NetworkPeer
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkPeerNames(arg1 string) ([]string, error) {
	fake.getNetworkPeerNamesMutex.Lock()
	ret, specificReturn := fake.getNetworkPeerNamesReturnsOnCall[len(fake.getNetworkPeerNamesArgsForCall)]
	fake.getNetworkPeerNamesArgsForCall = append(fake.getNetworkPeerNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkPeerNamesStub
	fakeReturns := fake.getNetworkPeerNamesReturns
	fake.recordInvocation("GetNetworkPeerNames", []interface{}{arg1})
	fake.getNetworkPeerNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkPeerNamesCallCount() int {
	fake.getNetworkPeerNamesMutex.RLock()
	defer fake.getNetworkPeerNamesMutex.RUnlock()
	return len(fake.getNetworkPeerNamesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkPeerNamesCalls(stub func(string) ([]string, error)) {
	fake.getNetworkPeerNamesMutex.Lock()
	defer fake.getNetworkPeerNamesMutex.Unlock()
	fake.GetNetworkPeerNamesStub = stub
}

func (fake *FakeContainerServer) GetNetworkPeerNamesArgsForCall(i int) string {
	fake.getNetworkPeerNamesMutex.RLock()
	defer fake.getNetworkPeerNamesMutex.RUnlock()
	argsForCall := fake.getNetworkPeerNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkPeerNamesReturns(result1 []string, result2 error) {
	fake.getNetworkPeerNamesMutex.Lock()
	defer fake.getNetworkPeerNamesMutex.Unlock()
	fake.GetNetworkPeerNamesStub = nil
	fake.getNetworkPeerNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkPeerNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkPeerNamesMutex.Lock()
	defer fake.getNetworkPeerNamesMutex.Unlock()
	fake.GetNetworkPeerNamesStub = nil
	if fake.getNetworkPeerNamesReturnsOnCall == nil {
		fake.getNetworkPeerNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkPeerNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkPeers(arg1 string) ([]api.NetworkPeer, error) {
	fake.getNetworkPeersMutex.Lock()
	ret, specificReturn := fake.getNetworkPeersReturnsOnCall[len(fake.getNetworkPeersArgsForCall)]
	fake.getNetworkPeersArgsForCall = append(fake.getNetworkPeersArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkPeersStub
	fakeReturns := fake.getNetworkPeersReturns
	fake.recordInvocation("GetNetworkPeers", []interface{}{arg1})
	fake.getNetworkPeersMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkPeersCallCount() int {
	fake.getNetworkPeersMutex.RLock()
	defer fake.getNetworkPeersMutex.RUnlock()
	return len(fake.getNetworkPeersArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkPeersCalls(stub func(string) ([]api.NetworkPeer, error)) {
	fake.getNetworkPeersMutex.Lock()
	defer fake.getNetworkPeersMutex.Unlock()
	fake.GetNetworkPeersStub = stub
}

func (fake *FakeContainerServer) GetNetworkPeersArgsForCall(i int) string {
	fake.getNetworkPeersMutex.RLock()
	defer fake.getNetworkPeersMutex.RUnlock()
	argsForCall := fake.getNetworkPeersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkPeersReturns(result1 []api.NetworkPeer, result2 error) {
	fake.getNetworkPeersMutex.Lock()
	defer fake.getNetworkPeersMutex.Unlock()
	fake.GetNetworkPeersStub = nil
	fake.getNetworkPeersReturns = struct {
		result1 []api.NetworkPeer
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkPeersReturnsOnCall(i int, result1 []api.NetworkPeer, result2 error) {
	fake.getNetworkPeersMutex.Lock()
	defer fake.getNetworkPeersMutex.Unlock()
	fake.GetNetworkPeersStub = nil
	if fake.getNetworkPeersReturnsOnCall == nil {
		fake.getNetworkPeersReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkPeer
			result2 error
		})
	}
	fake.getNetworkPeersReturnsOnCall[i] = struct {
		result1 []api.NetworkPeer
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkState(arg1 string) (*api.NetworkState, error) {
	fake.getNetworkStateMutex.Lock()
	ret, specificReturn := fake.getNetworkStateReturnsOnCall[len(fake.getNetworkStateArgsForCall)]
	fake.getNetworkStateArgsForCall = append(fake.getNetworkStateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkStateStub
	fakeReturns := fake.getNetworkStateReturns
	fake.recordInvocation("GetNetworkState", []interface{}{arg1})
	fake.getNetworkStateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkStateCallCount() int {
	fake.getNetworkStateMutex.RLock()
	defer fake.getNetworkStateMutex.RUnlock()
	return len(fake.getNetworkStateArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkStateCalls(stub func(string) (*api.NetworkState, error)) {
	fake.getNetworkStateMutex.Lock()
	defer fake.getNetworkStateMutex.Unlock()
	fake.GetNetworkStateStub = stub
}

func (fake *FakeContainerServer) GetNetworkStateArgsForCall(i int) string {
	fake.getNetworkStateMutex.RLock()
	defer fake.getNetworkStateMutex.RUnlock()
	argsForCall := fake.getNetworkStateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkStateReturns(result1 *api.NetworkState, result2 error) {
	fake.getNetworkStateMutex.Lock()
	defer fake.getNetworkStateMutex.Unlock()
	fake.GetNetworkStateStub = nil
	fake.getNetworkStateReturns = struct {
		result1 *api.NetworkState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkStateReturnsOnCall(i int, result1 *api.NetworkState, result2 error) {
	fake.getNetworkStateMutex.Lock()
	defer fake.getNetworkStateMutex.Unlock()
	fake.GetNetworkStateStub = nil
	if fake.getNetworkStateReturnsOnCall == nil {
		fake.getNetworkStateReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkState
			result2 error
		})
	}
	fake.getNetworkStateReturnsOnCall[i] = struct {
		result1 *api.NetworkState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZone(arg1 string) (*api.NetworkZone, string, error) {
	fake.getNetworkZoneMutex.Lock()
	ret, specificReturn := fake.getNetworkZoneReturnsOnCall[len(fake.getNetworkZoneArgsForCall)]
	fake.getNetworkZoneArgsForCall = append(fake.getNetworkZoneArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkZoneStub
	fakeReturns := fake.getNetworkZoneReturns
	fake.recordInvocation("GetNetworkZone", []interface{}{arg1})
	fake.getNetworkZoneMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkZoneCallCount() int {
	fake.getNetworkZoneMutex.RLock()
	defer fake.getNetworkZoneMutex.RUnlock()
	return len(fake.getNetworkZoneArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZoneCalls(stub func(string) (*api.NetworkZone, string, error)) {
	fake.getNetworkZoneMutex.Lock()
	defer fake.getNetworkZoneMutex.Unlock()
	fake.GetNetworkZoneStub = stub
}

func (fake *FakeContainerServer) GetNetworkZoneArgsForCall(i int) string {
	fake.getNetworkZoneMutex.RLock()
	defer fake.getNetworkZoneMutex.RUnlock()
	argsForCall := fake.getNetworkZoneArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkZoneReturns(result1 *api.NetworkZone, result2 string, result3 error) {
	fake.getNetworkZoneMutex.Lock()
	defer fake.getNetworkZoneMutex.Unlock()
	fake.GetNetworkZoneStub = nil
	fake.getNetworkZoneReturns = struct {
		result1 *api.NetworkZone
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkZoneReturnsOnCall(i int, result1 *api.NetworkZone, result2 string, result3 error) {
	fake.getNetworkZoneMutex.Lock()
	defer fake.getNetworkZoneMutex.Unlock()
	fake.GetNetworkZoneStub = nil
	if fake.getNetworkZoneReturnsOnCall == nil {
		fake.getNetworkZoneReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkZone
			result2 string
			result3 error
		})
	}
	fake.getNetworkZoneReturnsOnCall[i] = struct {
		result1 *api.NetworkZone
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkZoneNames() ([]string, error) {
	fake.getNetworkZoneNamesMutex.Lock()
	ret, specificReturn := fake.getNetworkZoneNamesReturnsOnCall[len(fake.getNetworkZoneNamesArgsForCall)]
	fake.getNetworkZoneNamesArgsForCall = append(fake.getNetworkZoneNamesArgsForCall, struct {
	}{})
	stub := fake.GetNetworkZoneNamesStub
	fakeReturns := fake.getNetworkZoneNamesReturns
	fake.recordInvocation("GetNetworkZoneNames", []interface{}{})
	fake.getNetworkZoneNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkZoneNamesCallCount() int {
	fake.getNetworkZoneNamesMutex.RLock()
	defer fake.getNetworkZoneNamesMutex.RUnlock()
	return len(fake.getNetworkZoneNamesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZoneNamesCalls(stub func() ([]string, error)) {
	fake.getNetworkZoneNamesMutex.Lock()
	defer fake.getNetworkZoneNamesMutex.Unlock()
	fake.GetNetworkZoneNamesStub = stub
}

func (fake *FakeContainerServer) GetNetworkZoneNamesReturns(result1 []string, result2 error) {
	fake.getNetworkZoneNamesMutex.Lock()
	defer fake.getNetworkZoneNamesMutex.Unlock()
	fake.GetNetworkZoneNamesStub = nil
	fake.getNetworkZoneNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZoneNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkZoneNamesMutex.Lock()
	defer fake.getNetworkZoneNamesMutex.Unlock()
	fake.GetNetworkZoneNamesStub = nil
	if fake.getNetworkZoneNamesReturnsOnCall == nil {
		fake.getNetworkZoneNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkZoneNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZoneRecord(arg1 string, arg2 string) (*api.NetworkZoneRecord, string, error) {
	fake.getNetworkZoneRecordMutex.Lock()
	ret, specificReturn := fake.getNetworkZoneRecordReturnsOnCall[len(fake.getNetworkZoneRecordArgsForCall)]
	fake.getNetworkZoneRecordArgsForCall = append(fake.getNetworkZoneRecordArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetNetworkZoneRecordStub
	fakeReturns := fake.getNetworkZoneRecordReturns
	fake.recordInvocation("GetNetworkZoneRecord", []interface{}{arg1, arg2})
	fake.getNetworkZoneRecordMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetNetworkZoneRecordCallCount() int {
	fake.getNetworkZoneRecordMutex.RLock()
	defer fake.getNetworkZoneRecordMutex.RUnlock()
	return len(fake.getNetworkZoneRecordArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZoneRecordCalls(stub func(string, string) (*api.NetworkZoneRecord, string, error)) {
	fake.getNetworkZoneRecordMutex.Lock()
	defer fake.getNetworkZoneRecordMutex.Unlock()
	fake.GetNetworkZoneRecordStub = stub
}

func (fake *FakeContainerServer) GetNetworkZoneRecordArgsForCall(i int) (string, string) {
	fake.getNetworkZoneRecordMutex.RLock()
	defer fake.getNetworkZoneRecordMutex.RUnlock()
	argsForCall := fake.getNetworkZoneRecordArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetNetworkZoneRecordReturns(result1 *api.NetworkZoneRecord, result2 string, result3 error) {
	fake.getNetworkZoneRecordMutex.Lock()
	defer fake.getNetworkZoneRecordMutex.Unlock()
	fake.GetNetworkZoneRecordStub = nil
	fake.getNetworkZoneRecordReturns = struct {
		result1 *api.NetworkZoneRecord
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkZoneRecordReturnsOnCall(i int, result1 *api.NetworkZoneRecord, result2 string, result3 error) {
	fake.getNetworkZoneRecordMutex.Lock()
	defer fake.getNetworkZoneRecordMutex.Unlock()
	fake.GetNetworkZoneRecordStub = nil
	if fake.getNetworkZoneRecordReturnsOnCall == nil {
		fake.getNetworkZoneRecordReturnsOnCall = make(map[int]struct {
			result1 *api.NetworkZoneRecord
			result2 string
			result3 error
		})
	}
	fake.getNetworkZoneRecordReturnsOnCall[i] = struct {
		result1 *api.NetworkZoneRecord
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNames(arg1 string) ([]string, error) {
	fake.getNetworkZoneRecordNamesMutex.Lock()
	ret, specificReturn := fake.getNetworkZoneRecordNamesReturnsOnCall[len(fake.getNetworkZoneRecordNamesArgsForCall)]
	fake.getNetworkZoneRecordNamesArgsForCall = append(fake.getNetworkZoneRecordNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkZoneRecordNamesStub
	fakeReturns := fake.getNetworkZoneRecordNamesReturns
	fake.recordInvocation("GetNetworkZoneRecordNames", []interface{}{arg1})
	fake.getNetworkZoneRecordNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNamesCallCount() int {
	fake.getNetworkZoneRecordNamesMutex.RLock()
	defer fake.getNetworkZoneRecordNamesMutex.RUnlock()
	return len(fake.getNetworkZoneRecordNamesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNamesCalls(stub func(string) ([]string, error)) {
	fake.getNetworkZoneRecordNamesMutex.Lock()
	defer fake.getNetworkZoneRecordNamesMutex.Unlock()
	fake.GetNetworkZoneRecordNamesStub = stub
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNamesArgsForCall(i int) string {
	fake.getNetworkZoneRecordNamesMutex.RLock()
	defer fake.getNetworkZoneRecordNamesMutex.RUnlock()
	argsForCall := fake.getNetworkZoneRecordNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNamesReturns(result1 []string, result2 error) {
	fake.getNetworkZoneRecordNamesMutex.Lock()
	defer fake.getNetworkZoneRecordNamesMutex.Unlock()
	fake.GetNetworkZoneRecordNamesStub = nil
	fake.getNetworkZoneRecordNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZoneRecordNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getNetworkZoneRecordNamesMutex.Lock()
	defer fake.getNetworkZoneRecordNamesMutex.Unlock()
	fake.GetNetworkZoneRecordNamesStub = nil
	if fake.getNetworkZoneRecordNamesReturnsOnCall == nil {
		fake.getNetworkZoneRecordNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getNetworkZoneRecordNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZoneRecords(arg1 string) ([]api.NetworkZoneRecord, error) {
	fake.getNetworkZoneRecordsMutex.Lock()
	ret, specificReturn := fake.getNetworkZoneRecordsReturnsOnCall[len(fake.getNetworkZoneRecordsArgsForCall)]
	fake.getNetworkZoneRecordsArgsForCall = append(fake.getNetworkZoneRecordsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetNetworkZoneRecordsStub
	fakeReturns := fake.getNetworkZoneRecordsReturns
	fake.recordInvocation("GetNetworkZoneRecords", []interface{}{arg1})
	fake.getNetworkZoneRecordsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkZoneRecordsCallCount() int {
	fake.getNetworkZoneRecordsMutex.RLock()
	defer fake.getNetworkZoneRecordsMutex.RUnlock()
	return len(fake.getNetworkZoneRecordsArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZoneRecordsCalls(stub func(string) ([]api.NetworkZoneRecord, error)) {
	fake.getNetworkZoneRecordsMutex.Lock()
	defer fake.getNetworkZoneRecordsMutex.Unlock()
	fake.GetNetworkZoneRecordsStub = stub
}

func (fake *FakeContainerServer) GetNetworkZoneRecordsArgsForCall(i int) string {
	fake.getNetworkZoneRecordsMutex.RLock()
	defer fake.getNetworkZoneRecordsMutex.RUnlock()
	argsForCall := fake.getNetworkZoneRecordsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetNetworkZoneRecordsReturns(result1 []api.NetworkZoneRecord, result2 error) {
	fake.getNetworkZoneRecordsMutex.Lock()
	defer fake.getNetworkZoneRecordsMutex.Unlock()
	fake.GetNetworkZoneRecordsStub = nil
	fake.getNetworkZoneRecordsReturns = struct {
		result1 []api.NetworkZoneRecord
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZoneRecordsReturnsOnCall(i int, result1 []api.NetworkZoneRecord, result2 error) {
	fake.getNetworkZoneRecordsMutex.Lock()
	defer fake.getNetworkZoneRecordsMutex.Unlock()
	fake.GetNetworkZoneRecordsStub = nil
	if fake.getNetworkZoneRecordsReturnsOnCall == nil {
		fake.getNetworkZoneRecordsReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkZoneRecord
			result2 error
		})
	}
	fake.getNetworkZoneRecordsReturnsOnCall[i] = struct {
		result1 []api.NetworkZoneRecord
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZones() ([]api.NetworkZone, error) {
	fake.getNetworkZonesMutex.Lock()
	ret, specificReturn := fake.getNetworkZonesReturnsOnCall[len(fake.getNetworkZonesArgsForCall)]
	fake.getNetworkZonesArgsForCall = append(fake.getNetworkZonesArgsForCall, struct {
	}{})
	stub := fake.GetNetworkZonesStub
	fakeReturns := fake.getNetworkZonesReturns
	fake.recordInvocation("GetNetworkZones", []interface{}{})
	fake.getNetworkZonesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworkZonesCallCount() int {
	fake.getNetworkZonesMutex.RLock()
	defer fake.getNetworkZonesMutex.RUnlock()
	return len(fake.getNetworkZonesArgsForCall)
}

func (fake *FakeContainerServer) GetNetworkZonesCalls(stub func() ([]api.NetworkZone, error)) {
	fake.getNetworkZonesMutex.Lock()
	defer fake.getNetworkZonesMutex.Unlock()
	fake.GetNetworkZonesStub = stub
}

func (fake *FakeContainerServer) GetNetworkZonesReturns(result1 []api.NetworkZone, result2 error) {
	fake.getNetworkZonesMutex.Lock()
	defer fake.getNetworkZonesMutex.Unlock()
	fake.GetNetworkZonesStub = nil
	fake.getNetworkZonesReturns = struct {
		result1 []api.NetworkZone
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworkZonesReturnsOnCall(i int, result1 []api.NetworkZone, result2 error) {
	fake.getNetworkZonesMutex.Lock()
	defer fake.getNetworkZonesMutex.Unlock()
	fake.GetNetworkZonesStub = nil
	if fake.getNetworkZonesReturnsOnCall == nil {
		fake.getNetworkZonesReturnsOnCall = make(map[int]struct {
			result1 []api.NetworkZone
			result2 error
		})
	}
	fake.getNetworkZonesReturnsOnCall[i] = struct {
		result1 []api.NetworkZone
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworks() ([]api.Network, error) {
	fake.getNetworksMutex.Lock()
	ret, specificReturn := fake.getNetworksReturnsOnCall[len(fake.getNetworksArgsForCall)]
	fake.getNetworksArgsForCall = append(fake.getNetworksArgsForCall, struct {
	}{})
	stub := fake.GetNetworksStub
	fakeReturns := fake.getNetworksReturns
	fake.recordInvocation("GetNetworks", []interface{}{})
	fake.getNetworksMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetNetworksCallCount() int {
	fake.getNetworksMutex.RLock()
	defer fake.getNetworksMutex.RUnlock()
	return len(fake.getNetworksArgsForCall)
}

func (fake *FakeContainerServer) GetNetworksCalls(stub func() ([]api.Network, error)) {
	fake.getNetworksMutex.Lock()
	defer fake.getNetworksMutex.Unlock()
	fake.GetNetworksStub = stub
}

func (fake *FakeContainerServer) GetNetworksReturns(result1 []api.Network, result2 error) {
	fake.getNetworksMutex.Lock()
	defer fake.getNetworksMutex.Unlock()
	fake.GetNetworksStub = nil
	fake.getNetworksReturns = struct {
		result1 []api.Network
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetNetworksReturnsOnCall(i int, result1 []api.Network, result2 error) {
	fake.getNetworksMutex.Lock()
	defer fake.getNetworksMutex.Unlock()
	fake.GetNetworksStub = nil
	if fake.getNetworksReturnsOnCall == nil {
		fake.getNetworksReturnsOnCall = make(map[int]struct {
			result1 []api.Network
			result2 error
		})
	}
	fake.getNetworksReturnsOnCall[i] = struct {
		result1 []api.Network
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperation(arg1 string) (*api.Operation, string, error) {
	fake.getOperationMutex.Lock()
	ret, specificReturn := fake.getOperationReturnsOnCall[len(fake.getOperationArgsForCall)]
	fake.getOperationArgsForCall = append(fake.getOperationArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetOperationStub
	fakeReturns := fake.getOperationReturns
	fake.recordInvocation("GetOperation", []interface{}{arg1})
	fake.getOperationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetOperationCallCount() int {
	fake.getOperationMutex.RLock()
	defer fake.getOperationMutex.RUnlock()
	return len(fake.getOperationArgsForCall)
}

func (fake *FakeContainerServer) GetOperationCalls(stub func(string) (*api.Operation, string, error)) {
	fake.getOperationMutex.Lock()
	defer fake.getOperationMutex.Unlock()
	fake.GetOperationStub = stub
}

func (fake *FakeContainerServer) GetOperationArgsForCall(i int) string {
	fake.getOperationMutex.RLock()
	defer fake.getOperationMutex.RUnlock()
	argsForCall := fake.getOperationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetOperationReturns(result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationMutex.Lock()
	defer fake.getOperationMutex.Unlock()
	fake.GetOperationStub = nil
	fake.getOperationReturns = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationReturnsOnCall(i int, result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationMutex.Lock()
	defer fake.getOperationMutex.Unlock()
	fake.GetOperationStub = nil
	if fake.getOperationReturnsOnCall == nil {
		fake.getOperationReturnsOnCall = make(map[int]struct {
			result1 *api.Operation
			result2 string
			result3 error
		})
	}
	fake.getOperationReturnsOnCall[i] = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationUUIDs() ([]string, error) {
	fake.getOperationUUIDsMutex.Lock()
	ret, specificReturn := fake.getOperationUUIDsReturnsOnCall[len(fake.getOperationUUIDsArgsForCall)]
	fake.getOperationUUIDsArgsForCall = append(fake.getOperationUUIDsArgsForCall, struct {
	}{})
	stub := fake.GetOperationUUIDsStub
	fakeReturns := fake.getOperationUUIDsReturns
	fake.recordInvocation("GetOperationUUIDs", []interface{}{})
	fake.getOperationUUIDsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetOperationUUIDsCallCount() int {
	fake.getOperationUUIDsMutex.RLock()
	defer fake.getOperationUUIDsMutex.RUnlock()
	return len(fake.getOperationUUIDsArgsForCall)
}

func (fake *FakeContainerServer) GetOperationUUIDsCalls(stub func() ([]string, error)) {
	fake.getOperationUUIDsMutex.Lock()
	defer fake.getOperationUUIDsMutex.Unlock()
	fake.GetOperationUUIDsStub = stub
}

func (fake *FakeContainerServer) GetOperationUUIDsReturns(result1 []string, result2 error) {
	fake.getOperationUUIDsMutex.Lock()
	defer fake.getOperationUUIDsMutex.Unlock()
	fake.GetOperationUUIDsStub = nil
	fake.getOperationUUIDsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperationUUIDsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getOperationUUIDsMutex.Lock()
	defer fake.getOperationUUIDsMutex.Unlock()
	fake.GetOperationUUIDsStub = nil
	if fake.getOperationUUIDsReturnsOnCall == nil {
		fake.getOperationUUIDsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getOperationUUIDsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperationWait(arg1 string, arg2 int) (*api.Operation, string, error) {
	fake.getOperationWaitMutex.Lock()
	ret, specificReturn := fake.getOperationWaitReturnsOnCall[len(fake.getOperationWaitArgsForCall)]
	fake.getOperationWaitArgsForCall = append(fake.getOperationWaitArgsForCall, struct {
		arg1 string
		arg2 int
	}{arg1, arg2})
	stub := fake.GetOperationWaitStub
	fakeReturns := fake.getOperationWaitReturns
	fake.recordInvocation("GetOperationWait", []interface{}{arg1, arg2})
	fake.getOperationWaitMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetOperationWaitCallCount() int {
	fake.getOperationWaitMutex.RLock()
	defer fake.getOperationWaitMutex.RUnlock()
	return len(fake.getOperationWaitArgsForCall)
}

func (fake *FakeContainerServer) GetOperationWaitCalls(stub func(string, int) (*api.Operation, string, error)) {
	fake.getOperationWaitMutex.Lock()
	defer fake.getOperationWaitMutex.Unlock()
	fake.GetOperationWaitStub = stub
}

func (fake *FakeContainerServer) GetOperationWaitArgsForCall(i int) (string, int) {
	fake.getOperationWaitMutex.RLock()
	defer fake.getOperationWaitMutex.RUnlock()
	argsForCall := fake.getOperationWaitArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetOperationWaitReturns(result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationWaitMutex.Lock()
	defer fake.getOperationWaitMutex.Unlock()
	fake.GetOperationWaitStub = nil
	fake.getOperationWaitReturns = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationWaitReturnsOnCall(i int, result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationWaitMutex.Lock()
	defer fake.getOperationWaitMutex.Unlock()
	fake.GetOperationWaitStub = nil
	if fake.getOperationWaitReturnsOnCall == nil {
		fake.getOperationWaitReturnsOnCall = make(map[int]struct {
			result1 *api.Operation
			result2 string
			result3 error
		})
	}
	fake.getOperationWaitReturnsOnCall[i] = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationWaitSecret(arg1 string, arg2 string, arg3 int) (*api.Operation, string, error) {
	fake.getOperationWaitSecretMutex.Lock()
	ret, specificReturn := fake.getOperationWaitSecretReturnsOnCall[len(fake.getOperationWaitSecretArgsForCall)]
	fake.getOperationWaitSecretArgsForCall = append(fake.getOperationWaitSecretArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 int
	}{arg1, arg2, arg3})
	stub := fake.GetOperationWaitSecretStub
	fakeReturns := fake.getOperationWaitSecretReturns
	fake.recordInvocation("GetOperationWaitSecret", []interface{}{arg1, arg2, arg3})
	fake.getOperationWaitSecretMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetOperationWaitSecretCallCount() int {
	fake.getOperationWaitSecretMutex.RLock()
	defer fake.getOperationWaitSecretMutex.RUnlock()
	return len(fake.getOperationWaitSecretArgsForCall)
}

func (fake *FakeContainerServer) GetOperationWaitSecretCalls(stub func(string, string, int) (*api.Operation, string, error)) {
	fake.getOperationWaitSecretMutex.Lock()
	defer fake.getOperationWaitSecretMutex.Unlock()
	fake.GetOperationWaitSecretStub = stub
}

func (fake *FakeContainerServer) GetOperationWaitSecretArgsForCall(i int) (string, string, int) {
	fake.getOperationWaitSecretMutex.RLock()
	defer fake.getOperationWaitSecretMutex.RUnlock()
	argsForCall := fake.getOperationWaitSecretArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetOperationWaitSecretReturns(result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationWaitSecretMutex.Lock()
	defer fake.getOperationWaitSecretMutex.Unlock()
	fake.GetOperationWaitSecretStub = nil
	fake.getOperationWaitSecretReturns = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationWaitSecretReturnsOnCall(i int, result1 *api.Operation, result2 string, result3 error) {
	fake.getOperationWaitSecretMutex.Lock()
	defer fake.getOperationWaitSecretMutex.Unlock()
	fake.GetOperationWaitSecretStub = nil
	if fake.getOperationWaitSecretReturnsOnCall == nil {
		fake.getOperationWaitSecretReturnsOnCall = make(map[int]struct {
			result1 *api.Operation
			result2 string
			result3 error
		})
	}
	fake.getOperationWaitSecretReturnsOnCall[i] = struct {
		result1 *api.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetOperationWebsocket(arg1 string, arg2 string) (*websocket.Conn, error) {
	fake.getOperationWebsocketMutex.Lock()
	ret, specificReturn := fake.getOperationWebsocketReturnsOnCall[len(fake.getOperationWebsocketArgsForCall)]
	fake.getOperationWebsocketArgsForCall = append(fake.getOperationWebsocketArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetOperationWebsocketStub
	fakeReturns := fake.getOperationWebsocketReturns
	fake.recordInvocation("GetOperationWebsocket", []interface{}{arg1, arg2})
	fake.getOperationWebsocketMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetOperationWebsocketCallCount() int {
	fake.getOperationWebsocketMutex.RLock()
	defer fake.getOperationWebsocketMutex.RUnlock()
	return len(fake.getOperationWebsocketArgsForCall)
}

func (fake *FakeContainerServer) GetOperationWebsocketCalls(stub func(string, string) (*websocket.Conn, error)) {
	fake.getOperationWebsocketMutex.Lock()
	defer fake.getOperationWebsocketMutex.Unlock()
	fake.GetOperationWebsocketStub = stub
}

func (fake *FakeContainerServer) GetOperationWebsocketArgsForCall(i int) (string, string) {
	fake.getOperationWebsocketMutex.RLock()
	defer fake.getOperationWebsocketMutex.RUnlock()
	argsForCall := fake.getOperationWebsocketArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetOperationWebsocketReturns(result1 *websocket.Conn, result2 error) {
	fake.getOperationWebsocketMutex.Lock()
	defer fake.getOperationWebsocketMutex.Unlock()
	fake.GetOperationWebsocketStub = nil
	fake.getOperationWebsocketReturns = struct {
		result1 *websocket.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperationWebsocketReturnsOnCall(i int, result1 *websocket.Conn, result2 error) {
	fake.getOperationWebsocketMutex.Lock()
	defer fake.getOperationWebsocketMutex.Unlock()
	fake.GetOperationWebsocketStub = nil
	if fake.getOperationWebsocketReturnsOnCall == nil {
		fake.getOperationWebsocketReturnsOnCall = make(map[int]struct {
			result1 *websocket.Conn
			result2 error
		})
	}
	fake.getOperationWebsocketReturnsOnCall[i] = struct {
		result1 *websocket.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperations() ([]api.Operation, error) {
	fake.getOperationsMutex.Lock()
	ret, specificReturn := fake.getOperationsReturnsOnCall[len(fake.getOperationsArgsForCall)]
	fake.getOperationsArgsForCall = append(fake.getOperationsArgsForCall, struct {
	}{})
	stub := fake.GetOperationsStub
	fakeReturns := fake.getOperationsReturns
	fake.recordInvocation("GetOperations", []interface{}{})
	fake.getOperationsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetOperationsCallCount() int {
	fake.getOperationsMutex.RLock()
	defer fake.getOperationsMutex.RUnlock()
	return len(fake.getOperationsArgsForCall)
}

func (fake *FakeContainerServer) GetOperationsCalls(stub func() ([]api.Operation, error)) {
	fake.getOperationsMutex.Lock()
	defer fake.getOperationsMutex.Unlock()
	fake.GetOperationsStub = stub
}

func (fake *FakeContainerServer) GetOperationsReturns(result1 []api.Operation, result2 error) {
	fake.getOperationsMutex.Lock()
	defer fake.getOperationsMutex.Unlock()
	fake.GetOperationsStub = nil
	fake.getOperationsReturns = struct {
		result1 []api.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetOperationsReturnsOnCall(i int, result1 []api.Operation, result2 error) {
	fake.getOperationsMutex.Lock()
	defer fake.getOperationsMutex.Unlock()
	fake.GetOperationsStub = nil
	if fake.getOperationsReturnsOnCall == nil {
		fake.getOperationsReturnsOnCall = make(map[int]struct {
			result1 []api.Operation
			result2 error
		})
	}
	fake.getOperationsReturnsOnCall[i] = struct {
		result1 []api.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetPrivateImage(arg1 string, arg2 string) (*api.Image, string, error) {
	fake.getPrivateImageMutex.Lock()
	ret, specificReturn := fake.getPrivateImageReturnsOnCall[len(fake.getPrivateImageArgsForCall)]
	fake.getPrivateImageArgsForCall = append(fake.getPrivateImageArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetPrivateImageStub
	fakeReturns := fake.getPrivateImageReturns
	fake.recordInvocation("GetPrivateImage", []interface{}{arg1, arg2})
	fake.getPrivateImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetPrivateImageCallCount() int {
	fake.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	return len(fake.getPrivateImageArgsForCall)
}

func (fake *FakeContainerServer) GetPrivateImageCalls(stub func(string, string) (*api.Image, string, error)) {
	fake.getPrivateImageMutex.Lock()
	defer fake.getPrivateImageMutex.Unlock()
	fake.GetPrivateImageStub = stub
}

func (fake *FakeContainerServer) GetPrivateImageArgsForCall(i int) (string, string) {
	fake.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	argsForCall := fake.getPrivateImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetPrivateImageReturns(result1 *api.Image, result2 string, result3 error) {
	fake.getPrivateImageMutex.Lock()
	defer fake.getPrivateImageMutex.Unlock()
	fake.GetPrivateImageStub = nil
	fake.getPrivateImageReturns = struct {
		result1 *api.Image
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetPrivateImageReturnsOnCall(i int, result1 *api.Image, result2 string, result3 error) {
	fake.getPrivateImageMutex.Lock()
	defer fake.getPrivateImageMutex.Unlock()
	fake.GetPrivateImageStub = nil
	if fake.getPrivateImageReturnsOnCall == nil {
		fake.getPrivateImageReturnsOnCall = make(map[int]struct {
			result1 *api.Image
			result2 string
			result3 error
		})
	}
	fake.getPrivateImageReturnsOnCall[i] = struct {
		result1 *api.Image
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetPrivateImageFile(arg1 string, arg2 string, arg3 lxd.ImageFileRequest) (*lxd.ImageFileResponse, error) {
	fake.getPrivateImageFileMutex.Lock()
	ret, specificReturn := fake.getPrivateImageFileReturnsOnCall[len(fake.getPrivateImageFileArgsForCall)]
	fake.getPrivateImageFileArgsForCall = append(fake.getPrivateImageFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 lxd.ImageFileRequest
	}{arg1, arg2, arg3})
	stub := fake.GetPrivateImageFileStub
	fakeReturns := fake.getPrivateImageFileReturns
	fake.recordInvocation("GetPrivateImageFile", []interface{}{arg1, arg2, arg3})
	fake.getPrivateImageFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetPrivateImageFileCallCount() int {
	fake.getPrivateImageFileMutex.RLock()
	defer fake.getPrivateImageFileMutex.RUnlock()
	return len(fake.getPrivateImageFileArgsForCall)
}

func (fake *FakeContainerServer) GetPrivateImageFileCalls(stub func(string, string, lxd.ImageFileRequest) (*lxd.ImageFileResponse, error)) {
	fake.getPrivateImageFileMutex.Lock()
	defer fake.getPrivateImageFileMutex.Unlock()
	fake.GetPrivateImageFileStub = stub
}

func (fake *FakeContainerServer) GetPrivateImageFileArgsForCall(i int) (string, string, lxd.ImageFileRequest) {
	fake.getPrivateImageFileMutex.RLock()
	defer fake.getPrivateImageFileMutex.RUnlock()
	argsForCall := fake.getPrivateImageFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetPrivateImageFileReturns(result1 *lxd.ImageFileResponse, result2 error) {
	fake.getPrivateImageFileMutex.Lock()
	defer fake.getPrivateImageFileMutex.Unlock()
	fake.GetPrivateImageFileStub = nil
	fake.getPrivateImageFileReturns = struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetPrivateImageFileReturnsOnCall(i int, result1 *lxd.ImageFileResponse, result2 error) {
	fake.getPrivateImageFileMutex.Lock()
	defer fake.getPrivateImageFileMutex.Unlock()
	fake.GetPrivateImageFileStub = nil
	if fake.getPrivateImageFileReturnsOnCall == nil {
		fake.getPrivateImageFileReturnsOnCall = make(map[int]struct {
			result1 *lxd.ImageFileResponse
			result2 error
		})
	}
	fake.getPrivateImageFileReturnsOnCall[i] = struct {
		result1 *lxd.ImageFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProfile(arg1 string) (*api.Profile, string, error) {
	fake.getProfileMutex.Lock()
	ret, specificReturn := fake.getProfileReturnsOnCall[len(fake.getProfileArgsForCall)]
	fake.getProfileArgsForCall = append(fake.getProfileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProfileStub
	fakeReturns := fake.getProfileReturns
	fake.recordInvocation("GetProfile", []interface{}{arg1})
	fake.getProfileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetProfileCallCount() int {
	fake.getProfileMutex.RLock()
	defer fake.getProfileMutex.RUnlock()
	return len(fake.getProfileArgsForCall)
}

func (fake *FakeContainerServer) GetProfileCalls(stub func(string) (*api.Profile, string, error)) {
	fake.getProfileMutex.Lock()
	defer fake.getProfileMutex.Unlock()
	fake.GetProfileStub = stub
}

func (fake *FakeContainerServer) GetProfileArgsForCall(i int) string {
	fake.getProfileMutex.RLock()
	defer fake.getProfileMutex.RUnlock()
	argsForCall := fake.getProfileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetProfileReturns(result1 *api.Profile, result2 string, result3 error) {
	fake.getProfileMutex.Lock()
	defer fake.getProfileMutex.Unlock()
	fake.GetProfileStub = nil
	fake.getProfileReturns = struct {
		result1 *api.Profile
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetProfileReturnsOnCall(i int, result1 *api.Profile, result2 string, result3 error) {
	fake.getProfileMutex.Lock()
	defer fake.getProfileMutex.Unlock()
	fake.GetProfileStub = nil
	if fake.getProfileReturnsOnCall == nil {
		fake.getProfileReturnsOnCall = make(map[int]struct {
			result1 *api.Profile
			result2 string
			result3 error
		})
	}
	fake.getProfileReturnsOnCall[i] = struct {
		result1 *api.Profile
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetProfileNames() ([]string, error) {
	fake.getProfileNamesMutex.Lock()
	ret, specificReturn := fake.getProfileNamesReturnsOnCall[len(fake.getProfileNamesArgsForCall)]
	fake.getProfileNamesArgsForCall = append(fake.getProfileNamesArgsForCall, struct {
	}{})
	stub := fake.GetProfileNamesStub
	fakeReturns := fake.getProfileNamesReturns
	fake.recordInvocation("GetProfileNames", []interface{}{})
	fake.getProfileNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetProfileNamesCallCount() int {
	fake.getProfileNamesMutex.RLock()
	defer fake.getProfileNamesMutex.RUnlock()
	return len(fake.getProfileNamesArgsForCall)
}

func (fake *FakeContainerServer) GetProfileNamesCalls(stub func() ([]string, error)) {
	fake.getProfileNamesMutex.Lock()
	defer fake.getProfileNamesMutex.Unlock()
	fake.GetProfileNamesStub = stub
}

func (fake *FakeContainerServer) GetProfileNamesReturns(result1 []string, result2 error) {
	fake.getProfileNamesMutex.Lock()
	defer fake.getProfileNamesMutex.Unlock()
	fake.GetProfileNamesStub = nil
	fake.getProfileNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProfileNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getProfileNamesMutex.Lock()
	defer fake.getProfileNamesMutex.Unlock()
	fake.GetProfileNamesStub = nil
	if fake.getProfileNamesReturnsOnCall == nil {
		fake.getProfileNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getProfileNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProfiles() ([]api.Profile, error) {
	fake.getProfilesMutex.Lock()
	ret, specificReturn := fake.getProfilesReturnsOnCall[len(fake.getProfilesArgsForCall)]
	fake.getProfilesArgsForCall = append(fake.getProfilesArgsForCall, struct {
	}{})
	stub := fake.GetProfilesStub
	fakeReturns := fake.getProfilesReturns
	fake.recordInvocation("GetProfiles", []interface{}{})
	fake.getProfilesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetProfilesCallCount() int {
	fake.getProfilesMutex.RLock()
	defer fake.getProfilesMutex.RUnlock()
	return len(fake.getProfilesArgsForCall)
}

func (fake *FakeContainerServer) GetProfilesCalls(stub func() ([]api.Profile, error)) {
	fake.getProfilesMutex.Lock()
	defer fake.getProfilesMutex.Unlock()
	fake.GetProfilesStub = stub
}

func (fake *FakeContainerServer) GetProfilesReturns(result1 []api.Profile, result2 error) {
	fake.getProfilesMutex.Lock()
	defer fake.getProfilesMutex.Unlock()
	fake.GetProfilesStub = nil
	fake.getProfilesReturns = struct {
		result1 []api.Profile
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProfilesReturnsOnCall(i int, result1 []api.Profile, result2 error) {
	fake.getProfilesMutex.Lock()
	defer fake.getProfilesMutex.Unlock()
	fake.GetProfilesStub = nil
	if fake.getProfilesReturnsOnCall == nil {
		fake.getProfilesReturnsOnCall = make(map[int]struct {
			result1 []api.Profile
			result2 error
		})
	}
	fake.getProfilesReturnsOnCall[i] = struct {
		result1 []api.Profile
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProject(arg1 string) (*api.Project, string, error) {
	fake.getProjectMutex.Lock()
	ret, specificReturn := fake.getProjectReturnsOnCall[len(fake.getProjectArgsForCall)]
	fake.getProjectArgsForCall = append(fake.getProjectArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProjectStub
	fakeReturns := fake.getProjectReturns
	fake.recordInvocation("GetProject", []interface{}{arg1})
	fake.getProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetProjectCallCount() int {
	fake.getProjectMutex.RLock()
	defer fake.getProjectMutex.RUnlock()
	return len(fake.getProjectArgsForCall)
}

func (fake *FakeContainerServer) GetProjectCalls(stub func(string) (*api.Project, string, error)) {
	fake.getProjectMutex.Lock()
	defer fake.getProjectMutex.Unlock()
	fake.GetProjectStub = stub
}

func (fake *FakeContainerServer) GetProjectArgsForCall(i int) string {
	fake.getProjectMutex.RLock()
	defer fake.getProjectMutex.RUnlock()
	argsForCall := fake.getProjectArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetProjectReturns(result1 *api.Project, result2 string, result3 error) {
	fake.getProjectMutex.Lock()
	defer fake.getProjectMutex.Unlock()
	fake.GetProjectStub = nil
	fake.getProjectReturns = struct {
		result1 *api.Project
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetProjectReturnsOnCall(i int, result1 *api.Project, result2 string, result3 error) {
	fake.getProjectMutex.Lock()
	defer fake.getProjectMutex.Unlock()
	fake.GetProjectStub = nil
	if fake.getProjectReturnsOnCall == nil {
		fake.getProjectReturnsOnCall = make(map[int]struct {
			result1 *api.Project
			result2 string
			result3 error
		})
	}
	fake.getProjectReturnsOnCall[i] = struct {
		result1 *api.Project
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetProjectNames() ([]string, error) {
	fake.getProjectNamesMutex.Lock()
	ret, specificReturn := fake.getProjectNamesReturnsOnCall[len(fake.getProjectNamesArgsForCall)]
	fake.getProjectNamesArgsForCall = append(fake.getProjectNamesArgsForCall, struct {
	}{})
	stub := fake.GetProjectNamesStub
	fakeReturns := fake.getProjectNamesReturns
	fake.recordInvocation("GetProjectNames", []interface{}{})
	fake.getProjectNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetProjectNamesCallCount() int {
	fake.getProjectNamesMutex.RLock()
	defer fake.getProjectNamesMutex.RUnlock()
	return len(fake.getProjectNamesArgsForCall)
}

func (fake *FakeContainerServer) GetProjectNamesCalls(stub func() ([]string, error)) {
	fake.getProjectNamesMutex.Lock()
	defer fake.getProjectNamesMutex.Unlock()
	fake.GetProjectNamesStub = stub
}

func (fake *FakeContainerServer) GetProjectNamesReturns(result1 []string, result2 error) {
	fake.getProjectNamesMutex.Lock()
	defer fake.getProjectNamesMutex.Unlock()
	fake.GetProjectNamesStub = nil
	fake.getProjectNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProjectNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getProjectNamesMutex.Lock()
	defer fake.getProjectNamesMutex.Unlock()
	fake.GetProjectNamesStub = nil
	if fake.getProjectNamesReturnsOnCall == nil {
		fake.getProjectNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getProjectNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProjectState(arg1 string) (*api.ProjectState, error) {
	fake.getProjectStateMutex.Lock()
	ret, specificReturn := fake.getProjectStateReturnsOnCall[len(fake.getProjectStateArgsForCall)]
	fake.getProjectStateArgsForCall = append(fake.getProjectStateArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProjectStateStub
	fakeReturns := fake.getProjectStateReturns
	fake.recordInvocation("GetProjectState", []interface{}{arg1})
	fake.getProjectStateMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetProjectStateCallCount() int {
	fake.getProjectStateMutex.RLock()
	defer fake.getProjectStateMutex.RUnlock()
	return len(fake.getProjectStateArgsForCall)
}

func (fake *FakeContainerServer) GetProjectStateCalls(stub func(string) (*api.ProjectState, error)) {
	fake.getProjectStateMutex.Lock()
	defer fake.getProjectStateMutex.Unlock()
	fake.GetProjectStateStub = stub
}

func (fake *FakeContainerServer) GetProjectStateArgsForCall(i int) string {
	fake.getProjectStateMutex.RLock()
	defer fake.getProjectStateMutex.RUnlock()
	argsForCall := fake.getProjectStateArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetProjectStateReturns(result1 *api.ProjectState, result2 error) {
	fake.getProjectStateMutex.Lock()
	defer fake.getProjectStateMutex.Unlock()
	fake.GetProjectStateStub = nil
	fake.getProjectStateReturns = struct {
		result1 *api.ProjectState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProjectStateReturnsOnCall(i int, result1 *api.ProjectState, result2 error) {
	fake.getProjectStateMutex.Lock()
	defer fake.getProjectStateMutex.Unlock()
	fake.GetProjectStateStub = nil
	if fake.getProjectStateReturnsOnCall == nil {
		fake.getProjectStateReturnsOnCall = make(map[int]struct {
			result1 *api.ProjectState
			result2 error
		})
	}
	fake.getProjectStateReturnsOnCall[i] = struct {
		result1 *api.ProjectState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProjects() ([]api.Project, error) {
	fake.getProjectsMutex.Lock()
	ret, specificReturn := fake.getProjectsReturnsOnCall[len(fake.getProjectsArgsForCall)]
	fake.getProjectsArgsForCall = append(fake.getProjectsArgsForCall, struct {
	}{})
	stub := fake.GetProjectsStub
	fakeReturns := fake.getProjectsReturns
	fake.recordInvocation("GetProjects", []interface{}{})
	fake.getProjectsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetProjectsCallCount() int {
	fake.getProjectsMutex.RLock()
	defer fake.getProjectsMutex.RUnlock()
	return len(fake.getProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetProjectsCalls(stub func() ([]api.Project, error)) {
	fake.getProjectsMutex.Lock()
	defer fake.getProjectsMutex.Unlock()
	fake.GetProjectsStub = stub
}

func (fake *FakeContainerServer) GetProjectsReturns(result1 []api.Project, result2 error) {
	fake.getProjectsMutex.Lock()
	defer fake.getProjectsMutex.Unlock()
	fake.GetProjectsStub = nil
	fake.getProjectsReturns = struct {
		result1 []api.Project
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetProjectsReturnsOnCall(i int, result1 []api.Project, result2 error) {
	fake.getProjectsMutex.Lock()
	defer fake.getProjectsMutex.Unlock()
	fake.GetProjectsStub = nil
	if fake.getProjectsReturnsOnCall == nil {
		fake.getProjectsReturnsOnCall = make(map[int]struct {
			result1 []api.Project
			result2 error
		})
	}
	fake.getProjectsReturnsOnCall[i] = struct {
		result1 []api.Project
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetServer() (*api.Server, string, error) {
	fake.getServerMutex.Lock()
	ret, specificReturn := fake.getServerReturnsOnCall[len(fake.getServerArgsForCall)]
	fake.getServerArgsForCall = append(fake.getServerArgsForCall, struct {
	}{})
	stub := fake.GetServerStub
	fakeReturns := fake.getServerReturns
	fake.recordInvocation("GetServer", []interface{}{})
	fake.getServerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetServerCallCount() int {
	fake.getServerMutex.RLock()
	defer fake.getServerMutex.RUnlock()
	return len(fake.getServerArgsForCall)
}

func (fake *FakeContainerServer) GetServerCalls(stub func() (*api.Server, string, error)) {
	fake.getServerMutex.Lock()
	defer fake.getServerMutex.Unlock()
	fake.GetServerStub = stub
}

func (fake *FakeContainerServer) GetServerReturns(result1 *api.Server, result2 string, result3 error) {
	fake.getServerMutex.Lock()
	defer fake.getServerMutex.Unlock()
	fake.GetServerStub = nil
	fake.getServerReturns = struct {
		result1 *api.Server
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetServerReturnsOnCall(i int, result1 *api.Server, result2 string, result3 error) {
	fake.getServerMutex.Lock()
	defer fake.getServerMutex.Unlock()
	fake.GetServerStub = nil
	if fake.getServerReturnsOnCall == nil {
		fake.getServerReturnsOnCall = make(map[int]struct {
			result1 *api.Server
			result2 string
			result3 error
		})
	}
	fake.getServerReturnsOnCall[i] = struct {
		result1 *api.Server
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetServerResources() (*api.Resources, error) {
	fake.getServerResourcesMutex.Lock()
	ret, specificReturn := fake.getServerResourcesReturnsOnCall[len(fake.getServerResourcesArgsForCall)]
	fake.getServerResourcesArgsForCall = append(fake.getServerResourcesArgsForCall, struct {
	}{})
	stub := fake.GetServerResourcesStub
	fakeReturns := fake.getServerResourcesReturns
	fake.recordInvocation("GetServerResources", []interface{}{})
	fake.getServerResourcesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetServerResourcesCallCount() int {
	fake.getServerResourcesMutex.RLock()
	defer fake.getServerResourcesMutex.RUnlock()
	return len(fake.getServerResourcesArgsForCall)
}

func (fake *FakeContainerServer) GetServerResourcesCalls(stub func() (*api.Resources, error)) {
	fake.getServerResourcesMutex.Lock()
	defer fake.getServerResourcesMutex.Unlock()
	fake.GetServerResourcesStub = stub
}

func (fake *FakeContainerServer) GetServerResourcesReturns(result1 *api.Resources, result2 error) {
	fake.getServerResourcesMutex.Lock()
	defer fake.getServerResourcesMutex.Unlock()
	fake.GetServerResourcesStub = nil
	fake.getServerResourcesReturns = struct {
		result1 *api.Resources
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetServerResourcesReturnsOnCall(i int, result1 *api.Resources, result2 error) {
	fake.getServerResourcesMutex.Lock()
	defer fake.getServerResourcesMutex.Unlock()
	fake.GetServerResourcesStub = nil
	if fake.getServerResourcesReturnsOnCall == nil {
		fake.getServerResourcesReturnsOnCall = make(map[int]struct {
			result1 *api.Resources
			result2 error
		})
	}
	fake.getServerResourcesReturnsOnCall[i] = struct {
		result1 *api.Resources
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePool(arg1 string) (*api.StoragePool, string, error) {
	fake.getStoragePoolMutex.Lock()
	ret, specificReturn := fake.getStoragePoolReturnsOnCall[len(fake.getStoragePoolArgsForCall)]
	fake.getStoragePoolArgsForCall = append(fake.getStoragePoolArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolStub
	fakeReturns := fake.getStoragePoolReturns
	fake.recordInvocation("GetStoragePool", []interface{}{arg1})
	fake.getStoragePoolMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetStoragePoolCallCount() int {
	fake.getStoragePoolMutex.RLock()
	defer fake.getStoragePoolMutex.RUnlock()
	return len(fake.getStoragePoolArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolCalls(stub func(string) (*api.StoragePool, string, error)) {
	fake.getStoragePoolMutex.Lock()
	defer fake.getStoragePoolMutex.Unlock()
	fake.GetStoragePoolStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolArgsForCall(i int) string {
	fake.getStoragePoolMutex.RLock()
	defer fake.getStoragePoolMutex.RUnlock()
	argsForCall := fake.getStoragePoolArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolReturns(result1 *api.StoragePool, result2 string, result3 error) {
	fake.getStoragePoolMutex.Lock()
	defer fake.getStoragePoolMutex.Unlock()
	fake.GetStoragePoolStub = nil
	fake.getStoragePoolReturns = struct {
		result1 *api.StoragePool
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolReturnsOnCall(i int, result1 *api.StoragePool, result2 string, result3 error) {
	fake.getStoragePoolMutex.Lock()
	defer fake.getStoragePoolMutex.Unlock()
	fake.GetStoragePoolStub = nil
	if fake.getStoragePoolReturnsOnCall == nil {
		fake.getStoragePoolReturnsOnCall = make(map[int]struct {
			result1 *api.StoragePool
			result2 string
			result3 error
		})
	}
	fake.getStoragePoolReturnsOnCall[i] = struct {
		result1 *api.StoragePool
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolNames() ([]string, error) {
	fake.getStoragePoolNamesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolNamesReturnsOnCall[len(fake.getStoragePoolNamesArgsForCall)]
	fake.getStoragePoolNamesArgsForCall = append(fake.getStoragePoolNamesArgsForCall, struct {
	}{})
	stub := fake.GetStoragePoolNamesStub
	fakeReturns := fake.getStoragePoolNamesReturns
	fake.recordInvocation("GetStoragePoolNames", []interface{}{})
	fake.getStoragePoolNamesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolNamesCallCount() int {
	fake.getStoragePoolNamesMutex.RLock()
	defer fake.getStoragePoolNamesMutex.RUnlock()
	return len(fake.getStoragePoolNamesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolNamesCalls(stub func() ([]string, error)) {
	fake.getStoragePoolNamesMutex.Lock()
	defer fake.getStoragePoolNamesMutex.Unlock()
	fake.GetStoragePoolNamesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolNamesReturns(result1 []string, result2 error) {
	fake.getStoragePoolNamesMutex.Lock()
	defer fake.getStoragePoolNamesMutex.Unlock()
	fake.GetStoragePoolNamesStub = nil
	fake.getStoragePoolNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getStoragePoolNamesMutex.Lock()
	defer fake.getStoragePoolNamesMutex.Unlock()
	fake.GetStoragePoolNamesStub = nil
	if fake.getStoragePoolNamesReturnsOnCall == nil {
		fake.getStoragePoolNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getStoragePoolNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolResources(arg1 string) (*api.ResourcesStoragePool, error) {
	fake.getStoragePoolResourcesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolResourcesReturnsOnCall[len(fake.getStoragePoolResourcesArgsForCall)]
	fake.getStoragePoolResourcesArgsForCall = append(fake.getStoragePoolResourcesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolResourcesStub
	fakeReturns := fake.getStoragePoolResourcesReturns
	fake.recordInvocation("GetStoragePoolResources", []interface{}{arg1})
	fake.getStoragePoolResourcesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolResourcesCallCount() int {
	fake.getStoragePoolResourcesMutex.RLock()
	defer fake.getStoragePoolResourcesMutex.RUnlock()
	return len(fake.getStoragePoolResourcesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolResourcesCalls(stub func(string) (*api.ResourcesStoragePool, error)) {
	fake.getStoragePoolResourcesMutex.Lock()
	defer fake.getStoragePoolResourcesMutex.Unlock()
	fake.GetStoragePoolResourcesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolResourcesArgsForCall(i int) string {
	fake.getStoragePoolResourcesMutex.RLock()
	defer fake.getStoragePoolResourcesMutex.RUnlock()
	argsForCall := fake.getStoragePoolResourcesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolResourcesReturns(result1 *api.ResourcesStoragePool, result2 error) {
	fake.getStoragePoolResourcesMutex.Lock()
	defer fake.getStoragePoolResourcesMutex.Unlock()
	fake.GetStoragePoolResourcesStub = nil
	fake.getStoragePoolResourcesReturns = struct {
		result1 *api.ResourcesStoragePool
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolResourcesReturnsOnCall(i int, result1 *api.ResourcesStoragePool, result2 error) {
	fake.getStoragePoolResourcesMutex.Lock()
	defer fake.getStoragePoolResourcesMutex.Unlock()
	fake.GetStoragePoolResourcesStub = nil
	if fake.getStoragePoolResourcesReturnsOnCall == nil {
		fake.getStoragePoolResourcesReturnsOnCall = make(map[int]struct {
			result1 *api.ResourcesStoragePool
			result2 error
		})
	}
	fake.getStoragePoolResourcesReturnsOnCall[i] = struct {
		result1 *api.ResourcesStoragePool
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolume(arg1 string, arg2 string, arg3 string) (*api.StorageVolume, string, error) {
	fake.getStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeReturnsOnCall[len(fake.getStoragePoolVolumeArgsForCall)]
	fake.getStoragePoolVolumeArgsForCall = append(fake.getStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetStoragePoolVolumeStub
	fakeReturns := fake.getStoragePoolVolumeReturns
	fake.recordInvocation("GetStoragePoolVolume", []interface{}{arg1, arg2, arg3})
	fake.getStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeCallCount() int {
	fake.getStoragePoolVolumeMutex.RLock()
	defer fake.getStoragePoolVolumeMutex.RUnlock()
	return len(fake.getStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeCalls(stub func(string, string, string) (*api.StorageVolume, string, error)) {
	fake.getStoragePoolVolumeMutex.Lock()
	defer fake.getStoragePoolVolumeMutex.Unlock()
	fake.GetStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeArgsForCall(i int) (string, string, string) {
	fake.getStoragePoolVolumeMutex.RLock()
	defer fake.getStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeReturns(result1 *api.StorageVolume, result2 string, result3 error) {
	fake.getStoragePoolVolumeMutex.Lock()
	defer fake.getStoragePoolVolumeMutex.Unlock()
	fake.GetStoragePoolVolumeStub = nil
	fake.getStoragePoolVolumeReturns = struct {
		result1 *api.StorageVolume
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeReturnsOnCall(i int, result1 *api.StorageVolume, result2 string, result3 error) {
	fake.getStoragePoolVolumeMutex.Lock()
	defer fake.getStoragePoolVolumeMutex.Unlock()
	fake.GetStoragePoolVolumeStub = nil
	if fake.getStoragePoolVolumeReturnsOnCall == nil {
		fake.getStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 *api.StorageVolume
			result2 string
			result3 error
		})
	}
	fake.getStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 *api.StorageVolume
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackup(arg1 string, arg2 string, arg3 string) (*api.StoragePoolVolumeBackup, string, error) {
	fake.getStoragePoolVolumeBackupMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeBackupReturnsOnCall[len(fake.getStoragePoolVolumeBackupArgsForCall)]
	fake.getStoragePoolVolumeBackupArgsForCall = append(fake.getStoragePoolVolumeBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetStoragePoolVolumeBackupStub
	fakeReturns := fake.getStoragePoolVolumeBackupReturns
	fake.recordInvocation("GetStoragePoolVolumeBackup", []interface{}{arg1, arg2, arg3})
	fake.getStoragePoolVolumeBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupCallCount() int {
	fake.getStoragePoolVolumeBackupMutex.RLock()
	defer fake.getStoragePoolVolumeBackupMutex.RUnlock()
	return len(fake.getStoragePoolVolumeBackupArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupCalls(stub func(string, string, string) (*api.StoragePoolVolumeBackup, string, error)) {
	fake.getStoragePoolVolumeBackupMutex.Lock()
	defer fake.getStoragePoolVolumeBackupMutex.Unlock()
	fake.GetStoragePoolVolumeBackupStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupArgsForCall(i int) (string, string, string) {
	fake.getStoragePoolVolumeBackupMutex.RLock()
	defer fake.getStoragePoolVolumeBackupMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupReturns(result1 *api.StoragePoolVolumeBackup, result2 string, result3 error) {
	fake.getStoragePoolVolumeBackupMutex.Lock()
	defer fake.getStoragePoolVolumeBackupMutex.Unlock()
	fake.GetStoragePoolVolumeBackupStub = nil
	fake.getStoragePoolVolumeBackupReturns = struct {
		result1 *api.StoragePoolVolumeBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupReturnsOnCall(i int, result1 *api.StoragePoolVolumeBackup, result2 string, result3 error) {
	fake.getStoragePoolVolumeBackupMutex.Lock()
	defer fake.getStoragePoolVolumeBackupMutex.Unlock()
	fake.GetStoragePoolVolumeBackupStub = nil
	if fake.getStoragePoolVolumeBackupReturnsOnCall == nil {
		fake.getStoragePoolVolumeBackupReturnsOnCall = make(map[int]struct {
			result1 *api.StoragePoolVolumeBackup
			result2 string
			result3 error
		})
	}
	fake.getStoragePoolVolumeBackupReturnsOnCall[i] = struct {
		result1 *api.StoragePoolVolumeBackup
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFile(arg1 string, arg2 string, arg3 string, arg4 *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error) {
	fake.getStoragePoolVolumeBackupFileMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeBackupFileReturnsOnCall[len(fake.getStoragePoolVolumeBackupFileArgsForCall)]
	fake.getStoragePoolVolumeBackupFileArgsForCall = append(fake.getStoragePoolVolumeBackupFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 *lxd.BackupFileRequest
	}{arg1, arg2, arg3, arg4})
	stub := fake.GetStoragePoolVolumeBackupFileStub
	fakeReturns := fake.getStoragePoolVolumeBackupFileReturns
	fake.recordInvocation("GetStoragePoolVolumeBackupFile", []interface{}{arg1, arg2, arg3, arg4})
	fake.getStoragePoolVolumeBackupFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFileCallCount() int {
	fake.getStoragePoolVolumeBackupFileMutex.RLock()
	defer fake.getStoragePoolVolumeBackupFileMutex.RUnlock()
	return len(fake.getStoragePoolVolumeBackupFileArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFileCalls(stub func(string, string, string, *lxd.BackupFileRequest) (*lxd.BackupFileResponse, error)) {
	fake.getStoragePoolVolumeBackupFileMutex.Lock()
	defer fake.getStoragePoolVolumeBackupFileMutex.Unlock()
	fake.GetStoragePoolVolumeBackupFileStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFileArgsForCall(i int) (string, string, string, *lxd.BackupFileRequest) {
	fake.getStoragePoolVolumeBackupFileMutex.RLock()
	defer fake.getStoragePoolVolumeBackupFileMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeBackupFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFileReturns(result1 *lxd.BackupFileResponse, result2 error) {
	fake.getStoragePoolVolumeBackupFileMutex.Lock()
	defer fake.getStoragePoolVolumeBackupFileMutex.Unlock()
	fake.GetStoragePoolVolumeBackupFileStub = nil
	fake.getStoragePoolVolumeBackupFileReturns = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupFileReturnsOnCall(i int, result1 *lxd.BackupFileResponse, result2 error) {
	fake.getStoragePoolVolumeBackupFileMutex.Lock()
	defer fake.getStoragePoolVolumeBackupFileMutex.Unlock()
	fake.GetStoragePoolVolumeBackupFileStub = nil
	if fake.getStoragePoolVolumeBackupFileReturnsOnCall == nil {
		fake.getStoragePoolVolumeBackupFileReturnsOnCall = make(map[int]struct {
			result1 *lxd.BackupFileResponse
			result2 error
		})
	}
	fake.getStoragePoolVolumeBackupFileReturnsOnCall[i] = struct {
		result1 *lxd.BackupFileResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNames(arg1 string, arg2 string) ([]string, error) {
	fake.getStoragePoolVolumeBackupNamesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeBackupNamesReturnsOnCall[len(fake.getStoragePoolVolumeBackupNamesArgsForCall)]
	fake.getStoragePoolVolumeBackupNamesArgsForCall = append(fake.getStoragePoolVolumeBackupNamesArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetStoragePoolVolumeBackupNamesStub
	fakeReturns := fake.getStoragePoolVolumeBackupNamesReturns
	fake.recordInvocation("GetStoragePoolVolumeBackupNames", []interface{}{arg1, arg2})
	fake.getStoragePoolVolumeBackupNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNamesCallCount() int {
	fake.getStoragePoolVolumeBackupNamesMutex.RLock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.RUnlock()
	return len(fake.getStoragePoolVolumeBackupNamesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNamesCalls(stub func(string, string) ([]string, error)) {
	fake.getStoragePoolVolumeBackupNamesMutex.Lock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.Unlock()
	fake.GetStoragePoolVolumeBackupNamesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNamesArgsForCall(i int) (string, string) {
	fake.getStoragePoolVolumeBackupNamesMutex.RLock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeBackupNamesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNamesReturns(result1 []string, result2 error) {
	fake.getStoragePoolVolumeBackupNamesMutex.Lock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.Unlock()
	fake.GetStoragePoolVolumeBackupNamesStub = nil
	fake.getStoragePoolVolumeBackupNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getStoragePoolVolumeBackupNamesMutex.Lock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.Unlock()
	fake.GetStoragePoolVolumeBackupNamesStub = nil
	if fake.getStoragePoolVolumeBackupNamesReturnsOnCall == nil {
		fake.getStoragePoolVolumeBackupNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getStoragePoolVolumeBackupNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackups(arg1 string, arg2 string) ([]api.StoragePoolVolumeBackup, error) {
	fake.getStoragePoolVolumeBackupsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeBackupsReturnsOnCall[len(fake.getStoragePoolVolumeBackupsArgsForCall)]
	fake.getStoragePoolVolumeBackupsArgsForCall = append(fake.getStoragePoolVolumeBackupsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetStoragePoolVolumeBackupsStub
	fakeReturns := fake.getStoragePoolVolumeBackupsReturns
	fake.recordInvocation("GetStoragePoolVolumeBackups", []interface{}{arg1, arg2})
	fake.getStoragePoolVolumeBackupsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupsCallCount() int {
	fake.getStoragePoolVolumeBackupsMutex.RLock()
	defer fake.getStoragePoolVolumeBackupsMutex.RUnlock()
	return len(fake.getStoragePoolVolumeBackupsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupsCalls(stub func(string, string) ([]api.StoragePoolVolumeBackup, error)) {
	fake.getStoragePoolVolumeBackupsMutex.Lock()
	defer fake.getStoragePoolVolumeBackupsMutex.Unlock()
	fake.GetStoragePoolVolumeBackupsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupsArgsForCall(i int) (string, string) {
	fake.getStoragePoolVolumeBackupsMutex.RLock()
	defer fake.getStoragePoolVolumeBackupsMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeBackupsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupsReturns(result1 []api.StoragePoolVolumeBackup, result2 error) {
	fake.getStoragePoolVolumeBackupsMutex.Lock()
	defer fake.getStoragePoolVolumeBackupsMutex.Unlock()
	fake.GetStoragePoolVolumeBackupsStub = nil
	fake.getStoragePoolVolumeBackupsReturns = struct {
		result1 []api.StoragePoolVolumeBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeBackupsReturnsOnCall(i int, result1 []api.StoragePoolVolumeBackup, result2 error) {
	fake.getStoragePoolVolumeBackupsMutex.Lock()
	defer fake.getStoragePoolVolumeBackupsMutex.Unlock()
	fake.GetStoragePoolVolumeBackupsStub = nil
	if fake.getStoragePoolVolumeBackupsReturnsOnCall == nil {
		fake.getStoragePoolVolumeBackupsReturnsOnCall = make(map[int]struct {
			result1 []api.StoragePoolVolumeBackup
			result2 error
		})
	}
	fake.getStoragePoolVolumeBackupsReturnsOnCall[i] = struct {
		result1 []api.StoragePoolVolumeBackup
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNames(arg1 string) ([]string, error) {
	fake.getStoragePoolVolumeNamesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeNamesReturnsOnCall[len(fake.getStoragePoolVolumeNamesArgsForCall)]
	fake.getStoragePoolVolumeNamesArgsForCall = append(fake.getStoragePoolVolumeNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolVolumeNamesStub
	fakeReturns := fake.getStoragePoolVolumeNamesReturns
	fake.recordInvocation("GetStoragePoolVolumeNames", []interface{}{arg1})
	fake.getStoragePoolVolumeNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesCallCount() int {
	fake.getStoragePoolVolumeNamesMutex.RLock()
	defer fake.getStoragePoolVolumeNamesMutex.RUnlock()
	return len(fake.getStoragePoolVolumeNamesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesCalls(stub func(string) ([]string, error)) {
	fake.getStoragePoolVolumeNamesMutex.Lock()
	defer fake.getStoragePoolVolumeNamesMutex.Unlock()
	fake.GetStoragePoolVolumeNamesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesArgsForCall(i int) string {
	fake.getStoragePoolVolumeNamesMutex.RLock()
	defer fake.getStoragePoolVolumeNamesMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesReturns(result1 []string, result2 error) {
	fake.getStoragePoolVolumeNamesMutex.Lock()
	defer fake.getStoragePoolVolumeNamesMutex.Unlock()
	fake.GetStoragePoolVolumeNamesStub = nil
	fake.getStoragePoolVolumeNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getStoragePoolVolumeNamesMutex.Lock()
	defer fake.getStoragePoolVolumeNamesMutex.Unlock()
	fake.GetStoragePoolVolumeNamesStub = nil
	if fake.getStoragePoolVolumeNamesReturnsOnCall == nil {
		fake.getStoragePoolVolumeNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getStoragePoolVolumeNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjects(arg1 string) ([]string, error) {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeNamesAllProjectsReturnsOnCall[len(fake.getStoragePoolVolumeNamesAllProjectsArgsForCall)]
	fake.getStoragePoolVolumeNamesAllProjectsArgsForCall = append(fake.getStoragePoolVolumeNamesAllProjectsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolVolumeNamesAllProjectsStub
	fakeReturns := fake.getStoragePoolVolumeNamesAllProjectsReturns
	fake.recordInvocation("GetStoragePoolVolumeNamesAllProjects", []interface{}{arg1})
	fake.getStoragePoolVolumeNamesAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjectsCallCount() int {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.RUnlock()
	return len(fake.getStoragePoolVolumeNamesAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjectsCalls(stub func(string) ([]string, error)) {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumeNamesAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjectsArgsForCall(i int) string {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeNamesAllProjectsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjectsReturns(result1 []string, result2 error) {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumeNamesAllProjectsStub = nil
	fake.getStoragePoolVolumeNamesAllProjectsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeNamesAllProjectsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getStoragePoolVolumeNamesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumeNamesAllProjectsStub = nil
	if fake.getStoragePoolVolumeNamesAllProjectsReturnsOnCall == nil {
		fake.getStoragePoolVolumeNamesAllProjectsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getStoragePoolVolumeNamesAllProjectsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshot(arg1 string, arg2 string, arg3 string, arg4 string) (*api.StorageVolumeSnapshot, string, error) {
	fake.getStoragePoolVolumeSnapshotMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeSnapshotReturnsOnCall[len(fake.getStoragePoolVolumeSnapshotArgsForCall)]
	fake.getStoragePoolVolumeSnapshotArgsForCall = append(fake.getStoragePoolVolumeSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.GetStoragePoolVolumeSnapshotStub
	fakeReturns := fake.getStoragePoolVolumeSnapshotReturns
	fake.recordInvocation("GetStoragePoolVolumeSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.getStoragePoolVolumeSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotCallCount() int {
	fake.getStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotMutex.RUnlock()
	return len(fake.getStoragePoolVolumeSnapshotArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotCalls(stub func(string, string, string, string) (*api.StorageVolumeSnapshot, string, error)) {
	fake.getStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotArgsForCall(i int) (string, string, string, string) {
	fake.getStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotReturns(result1 *api.StorageVolumeSnapshot, result2 string, result3 error) {
	fake.getStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotStub = nil
	fake.getStoragePoolVolumeSnapshotReturns = struct {
		result1 *api.StorageVolumeSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotReturnsOnCall(i int, result1 *api.StorageVolumeSnapshot, result2 string, result3 error) {
	fake.getStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotStub = nil
	if fake.getStoragePoolVolumeSnapshotReturnsOnCall == nil {
		fake.getStoragePoolVolumeSnapshotReturnsOnCall = make(map[int]struct {
			result1 *api.StorageVolumeSnapshot
			result2 string
			result3 error
		})
	}
	fake.getStoragePoolVolumeSnapshotReturnsOnCall[i] = struct {
		result1 *api.StorageVolumeSnapshot
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNames(arg1 string, arg2 string, arg3 string) ([]string, error) {
	fake.getStoragePoolVolumeSnapshotNamesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeSnapshotNamesReturnsOnCall[len(fake.getStoragePoolVolumeSnapshotNamesArgsForCall)]
	fake.getStoragePoolVolumeSnapshotNamesArgsForCall = append(fake.getStoragePoolVolumeSnapshotNamesArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetStoragePoolVolumeSnapshotNamesStub
	fakeReturns := fake.getStoragePoolVolumeSnapshotNamesReturns
	fake.recordInvocation("GetStoragePoolVolumeSnapshotNames", []interface{}{arg1, arg2, arg3})
	fake.getStoragePoolVolumeSnapshotNamesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNamesCallCount() int {
	fake.getStoragePoolVolumeSnapshotNamesMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.RUnlock()
	return len(fake.getStoragePoolVolumeSnapshotNamesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNamesCalls(stub func(string, string, string) ([]string, error)) {
	fake.getStoragePoolVolumeSnapshotNamesMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotNamesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNamesArgsForCall(i int) (string, string, string) {
	fake.getStoragePoolVolumeSnapshotNamesMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeSnapshotNamesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNamesReturns(result1 []string, result2 error) {
	fake.getStoragePoolVolumeSnapshotNamesMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotNamesStub = nil
	fake.getStoragePoolVolumeSnapshotNamesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotNamesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getStoragePoolVolumeSnapshotNamesMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotNamesStub = nil
	if fake.getStoragePoolVolumeSnapshotNamesReturnsOnCall == nil {
		fake.getStoragePoolVolumeSnapshotNamesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getStoragePoolVolumeSnapshotNamesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshots(arg1 string, arg2 string, arg3 string) ([]api.StorageVolumeSnapshot, error) {
	fake.getStoragePoolVolumeSnapshotsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeSnapshotsReturnsOnCall[len(fake.getStoragePoolVolumeSnapshotsArgsForCall)]
	fake.getStoragePoolVolumeSnapshotsArgsForCall = append(fake.getStoragePoolVolumeSnapshotsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetStoragePoolVolumeSnapshotsStub
	fakeReturns := fake.getStoragePoolVolumeSnapshotsReturns
	fake.recordInvocation("GetStoragePoolVolumeSnapshots", []interface{}{arg1, arg2, arg3})
	fake.getStoragePoolVolumeSnapshotsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotsCallCount() int {
	fake.getStoragePoolVolumeSnapshotsMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.RUnlock()
	return len(fake.getStoragePoolVolumeSnapshotsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotsCalls(stub func(string, string, string) ([]api.StorageVolumeSnapshot, error)) {
	fake.getStoragePoolVolumeSnapshotsMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotsArgsForCall(i int) (string, string, string) {
	fake.getStoragePoolVolumeSnapshotsMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeSnapshotsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotsReturns(result1 []api.StorageVolumeSnapshot, result2 error) {
	fake.getStoragePoolVolumeSnapshotsMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotsStub = nil
	fake.getStoragePoolVolumeSnapshotsReturns = struct {
		result1 []api.StorageVolumeSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeSnapshotsReturnsOnCall(i int, result1 []api.StorageVolumeSnapshot, result2 error) {
	fake.getStoragePoolVolumeSnapshotsMutex.Lock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.Unlock()
	fake.GetStoragePoolVolumeSnapshotsStub = nil
	if fake.getStoragePoolVolumeSnapshotsReturnsOnCall == nil {
		fake.getStoragePoolVolumeSnapshotsReturnsOnCall = make(map[int]struct {
			result1 []api.StorageVolumeSnapshot
			result2 error
		})
	}
	fake.getStoragePoolVolumeSnapshotsReturnsOnCall[i] = struct {
		result1 []api.StorageVolumeSnapshot
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeState(arg1 string, arg2 string, arg3 string) (*api.StorageVolumeState, error) {
	fake.getStoragePoolVolumeStateMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumeStateReturnsOnCall[len(fake.getStoragePoolVolumeStateArgsForCall)]
	fake.getStoragePoolVolumeStateArgsForCall = append(fake.getStoragePoolVolumeStateArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetStoragePoolVolumeStateStub
	fakeReturns := fake.getStoragePoolVolumeStateReturns
	fake.recordInvocation("GetStoragePoolVolumeState", []interface{}{arg1, arg2, arg3})
	fake.getStoragePoolVolumeStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumeStateCallCount() int {
	fake.getStoragePoolVolumeStateMutex.RLock()
	defer fake.getStoragePoolVolumeStateMutex.RUnlock()
	return len(fake.getStoragePoolVolumeStateArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumeStateCalls(stub func(string, string, string) (*api.StorageVolumeState, error)) {
	fake.getStoragePoolVolumeStateMutex.Lock()
	defer fake.getStoragePoolVolumeStateMutex.Unlock()
	fake.GetStoragePoolVolumeStateStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumeStateArgsForCall(i int) (string, string, string) {
	fake.getStoragePoolVolumeStateMutex.RLock()
	defer fake.getStoragePoolVolumeStateMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumeStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) GetStoragePoolVolumeStateReturns(result1 *api.StorageVolumeState, result2 error) {
	fake.getStoragePoolVolumeStateMutex.Lock()
	defer fake.getStoragePoolVolumeStateMutex.Unlock()
	fake.GetStoragePoolVolumeStateStub = nil
	fake.getStoragePoolVolumeStateReturns = struct {
		result1 *api.StorageVolumeState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumeStateReturnsOnCall(i int, result1 *api.StorageVolumeState, result2 error) {
	fake.getStoragePoolVolumeStateMutex.Lock()
	defer fake.getStoragePoolVolumeStateMutex.Unlock()
	fake.GetStoragePoolVolumeStateStub = nil
	if fake.getStoragePoolVolumeStateReturnsOnCall == nil {
		fake.getStoragePoolVolumeStateReturnsOnCall = make(map[int]struct {
			result1 *api.StorageVolumeState
			result2 error
		})
	}
	fake.getStoragePoolVolumeStateReturnsOnCall[i] = struct {
		result1 *api.StorageVolumeState
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumes(arg1 string) ([]api.StorageVolume, error) {
	fake.getStoragePoolVolumesMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumesReturnsOnCall[len(fake.getStoragePoolVolumesArgsForCall)]
	fake.getStoragePoolVolumesArgsForCall = append(fake.getStoragePoolVolumesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolVolumesStub
	fakeReturns := fake.getStoragePoolVolumesReturns
	fake.recordInvocation("GetStoragePoolVolumes", []interface{}{arg1})
	fake.getStoragePoolVolumesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesCallCount() int {
	fake.getStoragePoolVolumesMutex.RLock()
	defer fake.getStoragePoolVolumesMutex.RUnlock()
	return len(fake.getStoragePoolVolumesArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumesCalls(stub func(string) ([]api.StorageVolume, error)) {
	fake.getStoragePoolVolumesMutex.Lock()
	defer fake.getStoragePoolVolumesMutex.Unlock()
	fake.GetStoragePoolVolumesStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumesArgsForCall(i int) string {
	fake.getStoragePoolVolumesMutex.RLock()
	defer fake.getStoragePoolVolumesMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolVolumesReturns(result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesMutex.Lock()
	defer fake.getStoragePoolVolumesMutex.Unlock()
	fake.GetStoragePoolVolumesStub = nil
	fake.getStoragePoolVolumesReturns = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesReturnsOnCall(i int, result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesMutex.Lock()
	defer fake.getStoragePoolVolumesMutex.Unlock()
	fake.GetStoragePoolVolumesStub = nil
	if fake.getStoragePoolVolumesReturnsOnCall == nil {
		fake.getStoragePoolVolumesReturnsOnCall = make(map[int]struct {
			result1 []api.StorageVolume
			result2 error
		})
	}
	fake.getStoragePoolVolumesReturnsOnCall[i] = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjects(arg1 string) ([]api.StorageVolume, error) {
	fake.getStoragePoolVolumesAllProjectsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumesAllProjectsReturnsOnCall[len(fake.getStoragePoolVolumesAllProjectsArgsForCall)]
	fake.getStoragePoolVolumesAllProjectsArgsForCall = append(fake.getStoragePoolVolumesAllProjectsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetStoragePoolVolumesAllProjectsStub
	fakeReturns := fake.getStoragePoolVolumesAllProjectsReturns
	fake.recordInvocation("GetStoragePoolVolumesAllProjects", []interface{}{arg1})
	fake.getStoragePoolVolumesAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjectsCallCount() int {
	fake.getStoragePoolVolumesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.RUnlock()
	return len(fake.getStoragePoolVolumesAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjectsCalls(stub func(string) ([]api.StorageVolume, error)) {
	fake.getStoragePoolVolumesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjectsArgsForCall(i int) string {
	fake.getStoragePoolVolumesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumesAllProjectsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjectsReturns(result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesAllProjectsStub = nil
	fake.getStoragePoolVolumesAllProjectsReturns = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesAllProjectsReturnsOnCall(i int, result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesAllProjectsStub = nil
	if fake.getStoragePoolVolumesAllProjectsReturnsOnCall == nil {
		fake.getStoragePoolVolumesAllProjectsReturnsOnCall = make(map[int]struct {
			result1 []api.StorageVolume
			result2 error
		})
	}
	fake.getStoragePoolVolumesAllProjectsReturnsOnCall[i] = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilter(arg1 string, arg2 []string) ([]api.StorageVolume, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getStoragePoolVolumesWithFilterMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumesWithFilterReturnsOnCall[len(fake.getStoragePoolVolumesWithFilterArgsForCall)]
	fake.getStoragePoolVolumesWithFilterArgsForCall = append(fake.getStoragePoolVolumesWithFilterArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetStoragePoolVolumesWithFilterStub
	fakeReturns := fake.getStoragePoolVolumesWithFilterReturns
	fake.recordInvocation("GetStoragePoolVolumesWithFilter", []interface{}{arg1, arg2Copy})
	fake.getStoragePoolVolumesWithFilterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterCallCount() int {
	fake.getStoragePoolVolumesWithFilterMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterMutex.RUnlock()
	return len(fake.getStoragePoolVolumesWithFilterArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterCalls(stub func(string, []string) ([]api.StorageVolume, error)) {
	fake.getStoragePoolVolumesWithFilterMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterArgsForCall(i int) (string, []string) {
	fake.getStoragePoolVolumesWithFilterMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumesWithFilterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterReturns(result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesWithFilterMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterStub = nil
	fake.getStoragePoolVolumesWithFilterReturns = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterReturnsOnCall(i int, result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesWithFilterMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterStub = nil
	if fake.getStoragePoolVolumesWithFilterReturnsOnCall == nil {
		fake.getStoragePoolVolumesWithFilterReturnsOnCall = make(map[int]struct {
			result1 []api.StorageVolume
			result2 error
		})
	}
	fake.getStoragePoolVolumesWithFilterReturnsOnCall[i] = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjects(arg1 string, arg2 []string) ([]api.StorageVolume, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolVolumesWithFilterAllProjectsReturnsOnCall[len(fake.getStoragePoolVolumesWithFilterAllProjectsArgsForCall)]
	fake.getStoragePoolVolumesWithFilterAllProjectsArgsForCall = append(fake.getStoragePoolVolumesWithFilterAllProjectsArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.GetStoragePoolVolumesWithFilterAllProjectsStub
	fakeReturns := fake.getStoragePoolVolumesWithFilterAllProjectsReturns
	fake.recordInvocation("GetStoragePoolVolumesWithFilterAllProjects", []interface{}{arg1, arg2Copy})
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjectsCallCount() int {
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RUnlock()
	return len(fake.getStoragePoolVolumesWithFilterAllProjectsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjectsCalls(stub func(string, []string) ([]api.StorageVolume, error)) {
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterAllProjectsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjectsArgsForCall(i int) (string, []string) {
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RUnlock()
	argsForCall := fake.getStoragePoolVolumesWithFilterAllProjectsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjectsReturns(result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterAllProjectsStub = nil
	fake.getStoragePoolVolumesWithFilterAllProjectsReturns = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolVolumesWithFilterAllProjectsReturnsOnCall(i int, result1 []api.StorageVolume, result2 error) {
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Lock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.Unlock()
	fake.GetStoragePoolVolumesWithFilterAllProjectsStub = nil
	if fake.getStoragePoolVolumesWithFilterAllProjectsReturnsOnCall == nil {
		fake.getStoragePoolVolumesWithFilterAllProjectsReturnsOnCall = make(map[int]struct {
			result1 []api.StorageVolume
			result2 error
		})
	}
	fake.getStoragePoolVolumesWithFilterAllProjectsReturnsOnCall[i] = struct {
		result1 []api.StorageVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePools() ([]api.StoragePool, error) {
	fake.getStoragePoolsMutex.Lock()
	ret, specificReturn := fake.getStoragePoolsReturnsOnCall[len(fake.getStoragePoolsArgsForCall)]
	fake.getStoragePoolsArgsForCall = append(fake.getStoragePoolsArgsForCall, struct {
	}{})
	stub := fake.GetStoragePoolsStub
	fakeReturns := fake.getStoragePoolsReturns
	fake.recordInvocation("GetStoragePools", []interface{}{})
	fake.getStoragePoolsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetStoragePoolsCallCount() int {
	fake.getStoragePoolsMutex.RLock()
	defer fake.getStoragePoolsMutex.RUnlock()
	return len(fake.getStoragePoolsArgsForCall)
}

func (fake *FakeContainerServer) GetStoragePoolsCalls(stub func() ([]api.StoragePool, error)) {
	fake.getStoragePoolsMutex.Lock()
	defer fake.getStoragePoolsMutex.Unlock()
	fake.GetStoragePoolsStub = stub
}

func (fake *FakeContainerServer) GetStoragePoolsReturns(result1 []api.StoragePool, result2 error) {
	fake.getStoragePoolsMutex.Lock()
	defer fake.getStoragePoolsMutex.Unlock()
	fake.GetStoragePoolsStub = nil
	fake.getStoragePoolsReturns = struct {
		result1 []api.StoragePool
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetStoragePoolsReturnsOnCall(i int, result1 []api.StoragePool, result2 error) {
	fake.getStoragePoolsMutex.Lock()
	defer fake.getStoragePoolsMutex.Unlock()
	fake.GetStoragePoolsStub = nil
	if fake.getStoragePoolsReturnsOnCall == nil {
		fake.getStoragePoolsReturnsOnCall = make(map[int]struct {
			result1 []api.StoragePool
			result2 error
		})
	}
	fake.getStoragePoolsReturnsOnCall[i] = struct {
		result1 []api.StoragePool
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetWarning(arg1 string) (*api.Warning, string, error) {
	fake.getWarningMutex.Lock()
	ret, specificReturn := fake.getWarningReturnsOnCall[len(fake.getWarningArgsForCall)]
	fake.getWarningArgsForCall = append(fake.getWarningArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetWarningStub
	fakeReturns := fake.getWarningReturns
	fake.recordInvocation("GetWarning", []interface{}{arg1})
	fake.getWarningMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) GetWarningCallCount() int {
	fake.getWarningMutex.RLock()
	defer fake.getWarningMutex.RUnlock()
	return len(fake.getWarningArgsForCall)
}

func (fake *FakeContainerServer) GetWarningCalls(stub func(string) (*api.Warning, string, error)) {
	fake.getWarningMutex.Lock()
	defer fake.getWarningMutex.Unlock()
	fake.GetWarningStub = stub
}

func (fake *FakeContainerServer) GetWarningArgsForCall(i int) string {
	fake.getWarningMutex.RLock()
	defer fake.getWarningMutex.RUnlock()
	argsForCall := fake.getWarningArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) GetWarningReturns(result1 *api.Warning, result2 string, result3 error) {
	fake.getWarningMutex.Lock()
	defer fake.getWarningMutex.Unlock()
	fake.GetWarningStub = nil
	fake.getWarningReturns = struct {
		result1 *api.Warning
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetWarningReturnsOnCall(i int, result1 *api.Warning, result2 string, result3 error) {
	fake.getWarningMutex.Lock()
	defer fake.getWarningMutex.Unlock()
	fake.GetWarningStub = nil
	if fake.getWarningReturnsOnCall == nil {
		fake.getWarningReturnsOnCall = make(map[int]struct {
			result1 *api.Warning
			result2 string
			result3 error
		})
	}
	fake.getWarningReturnsOnCall[i] = struct {
		result1 *api.Warning
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) GetWarningUUIDs() ([]string, error) {
	fake.getWarningUUIDsMutex.Lock()
	ret, specificReturn := fake.getWarningUUIDsReturnsOnCall[len(fake.getWarningUUIDsArgsForCall)]
	fake.getWarningUUIDsArgsForCall = append(fake.getWarningUUIDsArgsForCall, struct {
	}{})
	stub := fake.GetWarningUUIDsStub
	fakeReturns := fake.getWarningUUIDsReturns
	fake.recordInvocation("GetWarningUUIDs", []interface{}{})
	fake.getWarningUUIDsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetWarningUUIDsCallCount() int {
	fake.getWarningUUIDsMutex.RLock()
	defer fake.getWarningUUIDsMutex.RUnlock()
	return len(fake.getWarningUUIDsArgsForCall)
}

func (fake *FakeContainerServer) GetWarningUUIDsCalls(stub func() ([]string, error)) {
	fake.getWarningUUIDsMutex.Lock()
	defer fake.getWarningUUIDsMutex.Unlock()
	fake.GetWarningUUIDsStub = stub
}

func (fake *FakeContainerServer) GetWarningUUIDsReturns(result1 []string, result2 error) {
	fake.getWarningUUIDsMutex.Lock()
	defer fake.getWarningUUIDsMutex.Unlock()
	fake.GetWarningUUIDsStub = nil
	fake.getWarningUUIDsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetWarningUUIDsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getWarningUUIDsMutex.Lock()
	defer fake.getWarningUUIDsMutex.Unlock()
	fake.GetWarningUUIDsStub = nil
	if fake.getWarningUUIDsReturnsOnCall == nil {
		fake.getWarningUUIDsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getWarningUUIDsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetWarnings() ([]api.Warning, error) {
	fake.getWarningsMutex.Lock()
	ret, specificReturn := fake.getWarningsReturnsOnCall[len(fake.getWarningsArgsForCall)]
	fake.getWarningsArgsForCall = append(fake.getWarningsArgsForCall, struct {
	}{})
	stub := fake.GetWarningsStub
	fakeReturns := fake.getWarningsReturns
	fake.recordInvocation("GetWarnings", []interface{}{})
	fake.getWarningsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) GetWarningsCallCount() int {
	fake.getWarningsMutex.RLock()
	defer fake.getWarningsMutex.RUnlock()
	return len(fake.getWarningsArgsForCall)
}

func (fake *FakeContainerServer) GetWarningsCalls(stub func() ([]api.Warning, error)) {
	fake.getWarningsMutex.Lock()
	defer fake.getWarningsMutex.Unlock()
	fake.GetWarningsStub = stub
}

func (fake *FakeContainerServer) GetWarningsReturns(result1 []api.Warning, result2 error) {
	fake.getWarningsMutex.Lock()
	defer fake.getWarningsMutex.Unlock()
	fake.GetWarningsStub = nil
	fake.getWarningsReturns = struct {
		result1 []api.Warning
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) GetWarningsReturnsOnCall(i int, result1 []api.Warning, result2 error) {
	fake.getWarningsMutex.Lock()
	defer fake.getWarningsMutex.Unlock()
	fake.GetWarningsStub = nil
	if fake.getWarningsReturnsOnCall == nil {
		fake.getWarningsReturnsOnCall = make(map[int]struct {
			result1 []api.Warning
			result2 error
		})
	}
	fake.getWarningsReturnsOnCall[i] = struct {
		result1 []api.Warning
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) HasExtension(arg1 string) bool {
	fake.hasExtensionMutex.Lock()
	ret, specificReturn := fake.hasExtensionReturnsOnCall[len(fake.hasExtensionArgsForCall)]
	fake.hasExtensionArgsForCall = append(fake.hasExtensionArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.HasExtensionStub
	fakeReturns := fake.hasExtensionReturns
	fake.recordInvocation("HasExtension", []interface{}{arg1})
	fake.hasExtensionMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) HasExtensionCallCount() int {
	fake.hasExtensionMutex.RLock()
	defer fake.hasExtensionMutex.RUnlock()
	return len(fake.hasExtensionArgsForCall)
}

func (fake *FakeContainerServer) HasExtensionCalls(stub func(string) bool) {
	fake.hasExtensionMutex.Lock()
	defer fake.hasExtensionMutex.Unlock()
	fake.HasExtensionStub = stub
}

func (fake *FakeContainerServer) HasExtensionArgsForCall(i int) string {
	fake.hasExtensionMutex.RLock()
	defer fake.hasExtensionMutex.RUnlock()
	argsForCall := fake.hasExtensionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) HasExtensionReturns(result1 bool) {
	fake.hasExtensionMutex.Lock()
	defer fake.hasExtensionMutex.Unlock()
	fake.HasExtensionStub = nil
	fake.hasExtensionReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeContainerServer) HasExtensionReturnsOnCall(i int, result1 bool) {
	fake.hasExtensionMutex.Lock()
	defer fake.hasExtensionMutex.Unlock()
	fake.HasExtensionStub = nil
	if fake.hasExtensionReturnsOnCall == nil {
		fake.hasExtensionReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasExtensionReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeContainerServer) IsClustered() bool {
	fake.isClusteredMutex.Lock()
	ret, specificReturn := fake.isClusteredReturnsOnCall[len(fake.isClusteredArgsForCall)]
	fake.isClusteredArgsForCall = append(fake.isClusteredArgsForCall, struct {
	}{})
	stub := fake.IsClusteredStub
	fakeReturns := fake.isClusteredReturns
	fake.recordInvocation("IsClustered", []interface{}{})
	fake.isClusteredMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) IsClusteredCallCount() int {
	fake.isClusteredMutex.RLock()
	defer fake.isClusteredMutex.RUnlock()
	return len(fake.isClusteredArgsForCall)
}

func (fake *FakeContainerServer) IsClusteredCalls(stub func() bool) {
	fake.isClusteredMutex.Lock()
	defer fake.isClusteredMutex.Unlock()
	fake.IsClusteredStub = stub
}

func (fake *FakeContainerServer) IsClusteredReturns(result1 bool) {
	fake.isClusteredMutex.Lock()
	defer fake.isClusteredMutex.Unlock()
	fake.IsClusteredStub = nil
	fake.isClusteredReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeContainerServer) IsClusteredReturnsOnCall(i int, result1 bool) {
	fake.isClusteredMutex.Lock()
	defer fake.isClusteredMutex.Unlock()
	fake.IsClusteredStub = nil
	if fake.isClusteredReturnsOnCall == nil {
		fake.isClusteredReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isClusteredReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeContainerServer) MigrateContainer(arg1 string, arg2 api.ContainerPost) (lxd.Operation, error) {
	fake.migrateContainerMutex.Lock()
	ret, specificReturn := fake.migrateContainerReturnsOnCall[len(fake.migrateContainerArgsForCall)]
	fake.migrateContainerArgsForCall = append(fake.migrateContainerArgsForCall, struct {
		arg1 string
		arg2 api.ContainerPost
	}{arg1, arg2})
	stub := fake.MigrateContainerStub
	fakeReturns := fake.migrateContainerReturns
	fake.recordInvocation("MigrateContainer", []interface{}{arg1, arg2})
	fake.migrateContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MigrateContainerCallCount() int {
	fake.migrateContainerMutex.RLock()
	defer fake.migrateContainerMutex.RUnlock()
	return len(fake.migrateContainerArgsForCall)
}

func (fake *FakeContainerServer) MigrateContainerCalls(stub func(string, api.ContainerPost) (lxd.Operation, error)) {
	fake.migrateContainerMutex.Lock()
	defer fake.migrateContainerMutex.Unlock()
	fake.MigrateContainerStub = stub
}

func (fake *FakeContainerServer) MigrateContainerArgsForCall(i int) (string, api.ContainerPost) {
	fake.migrateContainerMutex.RLock()
	defer fake.migrateContainerMutex.RUnlock()
	argsForCall := fake.migrateContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) MigrateContainerReturns(result1 lxd.Operation, result2 error) {
	fake.migrateContainerMutex.Lock()
	defer fake.migrateContainerMutex.Unlock()
	fake.MigrateContainerStub = nil
	fake.migrateContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.migrateContainerMutex.Lock()
	defer fake.migrateContainerMutex.Unlock()
	fake.MigrateContainerStub = nil
	if fake.migrateContainerReturnsOnCall == nil {
		fake.migrateContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.migrateContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateContainerSnapshot(arg1 string, arg2 string, arg3 api.ContainerSnapshotPost) (lxd.Operation, error) {
	fake.migrateContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.migrateContainerSnapshotReturnsOnCall[len(fake.migrateContainerSnapshotArgsForCall)]
	fake.migrateContainerSnapshotArgsForCall = append(fake.migrateContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPost
	}{arg1, arg2, arg3})
	stub := fake.MigrateContainerSnapshotStub
	fakeReturns := fake.migrateContainerSnapshotReturns
	fake.recordInvocation("MigrateContainerSnapshot", []interface{}{arg1, arg2, arg3})
	fake.migrateContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MigrateContainerSnapshotCallCount() int {
	fake.migrateContainerSnapshotMutex.RLock()
	defer fake.migrateContainerSnapshotMutex.RUnlock()
	return len(fake.migrateContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) MigrateContainerSnapshotCalls(stub func(string, string, api.ContainerSnapshotPost) (lxd.Operation, error)) {
	fake.migrateContainerSnapshotMutex.Lock()
	defer fake.migrateContainerSnapshotMutex.Unlock()
	fake.MigrateContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) MigrateContainerSnapshotArgsForCall(i int) (string, string, api.ContainerSnapshotPost) {
	fake.migrateContainerSnapshotMutex.RLock()
	defer fake.migrateContainerSnapshotMutex.RUnlock()
	argsForCall := fake.migrateContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) MigrateContainerSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.migrateContainerSnapshotMutex.Lock()
	defer fake.migrateContainerSnapshotMutex.Unlock()
	fake.MigrateContainerSnapshotStub = nil
	fake.migrateContainerSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateContainerSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.migrateContainerSnapshotMutex.Lock()
	defer fake.migrateContainerSnapshotMutex.Unlock()
	fake.MigrateContainerSnapshotStub = nil
	if fake.migrateContainerSnapshotReturnsOnCall == nil {
		fake.migrateContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.migrateContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateInstance(arg1 string, arg2 api.InstancePost) (lxd.Operation, error) {
	fake.migrateInstanceMutex.Lock()
	ret, specificReturn := fake.migrateInstanceReturnsOnCall[len(fake.migrateInstanceArgsForCall)]
	fake.migrateInstanceArgsForCall = append(fake.migrateInstanceArgsForCall, struct {
		arg1 string
		arg2 api.InstancePost
	}{arg1, arg2})
	stub := fake.MigrateInstanceStub
	fakeReturns := fake.migrateInstanceReturns
	fake.recordInvocation("MigrateInstance", []interface{}{arg1, arg2})
	fake.migrateInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MigrateInstanceCallCount() int {
	fake.migrateInstanceMutex.RLock()
	defer fake.migrateInstanceMutex.RUnlock()
	return len(fake.migrateInstanceArgsForCall)
}

func (fake *FakeContainerServer) MigrateInstanceCalls(stub func(string, api.InstancePost) (lxd.Operation, error)) {
	fake.migrateInstanceMutex.Lock()
	defer fake.migrateInstanceMutex.Unlock()
	fake.MigrateInstanceStub = stub
}

func (fake *FakeContainerServer) MigrateInstanceArgsForCall(i int) (string, api.InstancePost) {
	fake.migrateInstanceMutex.RLock()
	defer fake.migrateInstanceMutex.RUnlock()
	argsForCall := fake.migrateInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) MigrateInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.migrateInstanceMutex.Lock()
	defer fake.migrateInstanceMutex.Unlock()
	fake.MigrateInstanceStub = nil
	fake.migrateInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.migrateInstanceMutex.Lock()
	defer fake.migrateInstanceMutex.Unlock()
	fake.MigrateInstanceStub = nil
	if fake.migrateInstanceReturnsOnCall == nil {
		fake.migrateInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.migrateInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateInstanceSnapshot(arg1 string, arg2 string, arg3 api.InstanceSnapshotPost) (lxd.Operation, error) {
	fake.migrateInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.migrateInstanceSnapshotReturnsOnCall[len(fake.migrateInstanceSnapshotArgsForCall)]
	fake.migrateInstanceSnapshotArgsForCall = append(fake.migrateInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPost
	}{arg1, arg2, arg3})
	stub := fake.MigrateInstanceSnapshotStub
	fakeReturns := fake.migrateInstanceSnapshotReturns
	fake.recordInvocation("MigrateInstanceSnapshot", []interface{}{arg1, arg2, arg3})
	fake.migrateInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MigrateInstanceSnapshotCallCount() int {
	fake.migrateInstanceSnapshotMutex.RLock()
	defer fake.migrateInstanceSnapshotMutex.RUnlock()
	return len(fake.migrateInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) MigrateInstanceSnapshotCalls(stub func(string, string, api.InstanceSnapshotPost) (lxd.Operation, error)) {
	fake.migrateInstanceSnapshotMutex.Lock()
	defer fake.migrateInstanceSnapshotMutex.Unlock()
	fake.MigrateInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) MigrateInstanceSnapshotArgsForCall(i int) (string, string, api.InstanceSnapshotPost) {
	fake.migrateInstanceSnapshotMutex.RLock()
	defer fake.migrateInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.migrateInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) MigrateInstanceSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.migrateInstanceSnapshotMutex.Lock()
	defer fake.migrateInstanceSnapshotMutex.Unlock()
	fake.MigrateInstanceSnapshotStub = nil
	fake.migrateInstanceSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateInstanceSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.migrateInstanceSnapshotMutex.Lock()
	defer fake.migrateInstanceSnapshotMutex.Unlock()
	fake.MigrateInstanceSnapshotStub = nil
	if fake.migrateInstanceSnapshotReturnsOnCall == nil {
		fake.migrateInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.migrateInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateStoragePoolVolume(arg1 string, arg2 api.StorageVolumePost) (lxd.Operation, error) {
	fake.migrateStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.migrateStoragePoolVolumeReturnsOnCall[len(fake.migrateStoragePoolVolumeArgsForCall)]
	fake.migrateStoragePoolVolumeArgsForCall = append(fake.migrateStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 api.StorageVolumePost
	}{arg1, arg2})
	stub := fake.MigrateStoragePoolVolumeStub
	fakeReturns := fake.migrateStoragePoolVolumeReturns
	fake.recordInvocation("MigrateStoragePoolVolume", []interface{}{arg1, arg2})
	fake.migrateStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MigrateStoragePoolVolumeCallCount() int {
	fake.migrateStoragePoolVolumeMutex.RLock()
	defer fake.migrateStoragePoolVolumeMutex.RUnlock()
	return len(fake.migrateStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) MigrateStoragePoolVolumeCalls(stub func(string, api.StorageVolumePost) (lxd.Operation, error)) {
	fake.migrateStoragePoolVolumeMutex.Lock()
	defer fake.migrateStoragePoolVolumeMutex.Unlock()
	fake.MigrateStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) MigrateStoragePoolVolumeArgsForCall(i int) (string, api.StorageVolumePost) {
	fake.migrateStoragePoolVolumeMutex.RLock()
	defer fake.migrateStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.migrateStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) MigrateStoragePoolVolumeReturns(result1 lxd.Operation, result2 error) {
	fake.migrateStoragePoolVolumeMutex.Lock()
	defer fake.migrateStoragePoolVolumeMutex.Unlock()
	fake.MigrateStoragePoolVolumeStub = nil
	fake.migrateStoragePoolVolumeReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MigrateStoragePoolVolumeReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.migrateStoragePoolVolumeMutex.Lock()
	defer fake.migrateStoragePoolVolumeMutex.Unlock()
	fake.MigrateStoragePoolVolumeStub = nil
	if fake.migrateStoragePoolVolumeReturnsOnCall == nil {
		fake.migrateStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.migrateStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MoveStoragePoolVolume(arg1 string, arg2 lxd.InstanceServer, arg3 string, arg4 api.StorageVolume, arg5 *lxd.StoragePoolVolumeMoveArgs) (lxd.RemoteOperation, error) {
	fake.moveStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.moveStoragePoolVolumeReturnsOnCall[len(fake.moveStoragePoolVolumeArgsForCall)]
	fake.moveStoragePoolVolumeArgsForCall = append(fake.moveStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 lxd.InstanceServer
		arg3 string
		arg4 api.StorageVolume
		arg5 *lxd.StoragePoolVolumeMoveArgs
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.MoveStoragePoolVolumeStub
	fakeReturns := fake.moveStoragePoolVolumeReturns
	fake.recordInvocation("MoveStoragePoolVolume", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.moveStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) MoveStoragePoolVolumeCallCount() int {
	fake.moveStoragePoolVolumeMutex.RLock()
	defer fake.moveStoragePoolVolumeMutex.RUnlock()
	return len(fake.moveStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) MoveStoragePoolVolumeCalls(stub func(string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeMoveArgs) (lxd.RemoteOperation, error)) {
	fake.moveStoragePoolVolumeMutex.Lock()
	defer fake.moveStoragePoolVolumeMutex.Unlock()
	fake.MoveStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) MoveStoragePoolVolumeArgsForCall(i int) (string, lxd.InstanceServer, string, api.StorageVolume, *lxd.StoragePoolVolumeMoveArgs) {
	fake.moveStoragePoolVolumeMutex.RLock()
	defer fake.moveStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.moveStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeContainerServer) MoveStoragePoolVolumeReturns(result1 lxd.RemoteOperation, result2 error) {
	fake.moveStoragePoolVolumeMutex.Lock()
	defer fake.moveStoragePoolVolumeMutex.Unlock()
	fake.MoveStoragePoolVolumeStub = nil
	fake.moveStoragePoolVolumeReturns = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) MoveStoragePoolVolumeReturnsOnCall(i int, result1 lxd.RemoteOperation, result2 error) {
	fake.moveStoragePoolVolumeMutex.Lock()
	defer fake.moveStoragePoolVolumeMutex.Unlock()
	fake.MoveStoragePoolVolumeStub = nil
	if fake.moveStoragePoolVolumeReturnsOnCall == nil {
		fake.moveStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 lxd.RemoteOperation
			result2 error
		})
	}
	fake.moveStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 lxd.RemoteOperation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RawOperation(arg1 string, arg2 string, arg3 any, arg4 string) (lxd.Operation, string, error) {
	fake.rawOperationMutex.Lock()
	ret, specificReturn := fake.rawOperationReturnsOnCall[len(fake.rawOperationArgsForCall)]
	fake.rawOperationArgsForCall = append(fake.rawOperationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 any
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.RawOperationStub
	fakeReturns := fake.rawOperationReturns
	fake.recordInvocation("RawOperation", []interface{}{arg1, arg2, arg3, arg4})
	fake.rawOperationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) RawOperationCallCount() int {
	fake.rawOperationMutex.RLock()
	defer fake.rawOperationMutex.RUnlock()
	return len(fake.rawOperationArgsForCall)
}

func (fake *FakeContainerServer) RawOperationCalls(stub func(string, string, any, string) (lxd.Operation, string, error)) {
	fake.rawOperationMutex.Lock()
	defer fake.rawOperationMutex.Unlock()
	fake.RawOperationStub = stub
}

func (fake *FakeContainerServer) RawOperationArgsForCall(i int) (string, string, any, string) {
	fake.rawOperationMutex.RLock()
	defer fake.rawOperationMutex.RUnlock()
	argsForCall := fake.rawOperationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) RawOperationReturns(result1 lxd.Operation, result2 string, result3 error) {
	fake.rawOperationMutex.Lock()
	defer fake.rawOperationMutex.Unlock()
	fake.RawOperationStub = nil
	fake.rawOperationReturns = struct {
		result1 lxd.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) RawOperationReturnsOnCall(i int, result1 lxd.Operation, result2 string, result3 error) {
	fake.rawOperationMutex.Lock()
	defer fake.rawOperationMutex.Unlock()
	fake.RawOperationStub = nil
	if fake.rawOperationReturnsOnCall == nil {
		fake.rawOperationReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 string
			result3 error
		})
	}
	fake.rawOperationReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) RawQuery(arg1 string, arg2 string, arg3 any, arg4 string) (*api.Response, string, error) {
	fake.rawQueryMutex.Lock()
	ret, specificReturn := fake.rawQueryReturnsOnCall[len(fake.rawQueryArgsForCall)]
	fake.rawQueryArgsForCall = append(fake.rawQueryArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 any
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.RawQueryStub
	fakeReturns := fake.rawQueryReturns
	fake.recordInvocation("RawQuery", []interface{}{arg1, arg2, arg3, arg4})
	fake.rawQueryMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerServer) RawQueryCallCount() int {
	fake.rawQueryMutex.RLock()
	defer fake.rawQueryMutex.RUnlock()
	return len(fake.rawQueryArgsForCall)
}

func (fake *FakeContainerServer) RawQueryCalls(stub func(string, string, any, string) (*api.Response, string, error)) {
	fake.rawQueryMutex.Lock()
	defer fake.rawQueryMutex.Unlock()
	fake.RawQueryStub = stub
}

func (fake *FakeContainerServer) RawQueryArgsForCall(i int) (string, string, any, string) {
	fake.rawQueryMutex.RLock()
	defer fake.rawQueryMutex.RUnlock()
	argsForCall := fake.rawQueryArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) RawQueryReturns(result1 *api.Response, result2 string, result3 error) {
	fake.rawQueryMutex.Lock()
	defer fake.rawQueryMutex.Unlock()
	fake.RawQueryStub = nil
	fake.rawQueryReturns = struct {
		result1 *api.Response
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) RawQueryReturnsOnCall(i int, result1 *api.Response, result2 string, result3 error) {
	fake.rawQueryMutex.Lock()
	defer fake.rawQueryMutex.Unlock()
	fake.RawQueryStub = nil
	if fake.rawQueryReturnsOnCall == nil {
		fake.rawQueryReturnsOnCall = make(map[int]struct {
			result1 *api.Response
			result2 string
			result3 error
		})
	}
	fake.rawQueryReturnsOnCall[i] = struct {
		result1 *api.Response
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerServer) RawWebsocket(arg1 string) (*websocket.Conn, error) {
	fake.rawWebsocketMutex.Lock()
	ret, specificReturn := fake.rawWebsocketReturnsOnCall[len(fake.rawWebsocketArgsForCall)]
	fake.rawWebsocketArgsForCall = append(fake.rawWebsocketArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RawWebsocketStub
	fakeReturns := fake.rawWebsocketReturns
	fake.recordInvocation("RawWebsocket", []interface{}{arg1})
	fake.rawWebsocketMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RawWebsocketCallCount() int {
	fake.rawWebsocketMutex.RLock()
	defer fake.rawWebsocketMutex.RUnlock()
	return len(fake.rawWebsocketArgsForCall)
}

func (fake *FakeContainerServer) RawWebsocketCalls(stub func(string) (*websocket.Conn, error)) {
	fake.rawWebsocketMutex.Lock()
	defer fake.rawWebsocketMutex.Unlock()
	fake.RawWebsocketStub = stub
}

func (fake *FakeContainerServer) RawWebsocketArgsForCall(i int) string {
	fake.rawWebsocketMutex.RLock()
	defer fake.rawWebsocketMutex.RUnlock()
	argsForCall := fake.rawWebsocketArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) RawWebsocketReturns(result1 *websocket.Conn, result2 error) {
	fake.rawWebsocketMutex.Lock()
	defer fake.rawWebsocketMutex.Unlock()
	fake.RawWebsocketStub = nil
	fake.rawWebsocketReturns = struct {
		result1 *websocket.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RawWebsocketReturnsOnCall(i int, result1 *websocket.Conn, result2 error) {
	fake.rawWebsocketMutex.Lock()
	defer fake.rawWebsocketMutex.Unlock()
	fake.RawWebsocketStub = nil
	if fake.rawWebsocketReturnsOnCall == nil {
		fake.rawWebsocketReturnsOnCall = make(map[int]struct {
			result1 *websocket.Conn
			result2 error
		})
	}
	fake.rawWebsocketReturnsOnCall[i] = struct {
		result1 *websocket.Conn
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RefreshImage(arg1 string) (lxd.Operation, error) {
	fake.refreshImageMutex.Lock()
	ret, specificReturn := fake.refreshImageReturnsOnCall[len(fake.refreshImageArgsForCall)]
	fake.refreshImageArgsForCall = append(fake.refreshImageArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RefreshImageStub
	fakeReturns := fake.refreshImageReturns
	fake.recordInvocation("RefreshImage", []interface{}{arg1})
	fake.refreshImageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RefreshImageCallCount() int {
	fake.refreshImageMutex.RLock()
	defer fake.refreshImageMutex.RUnlock()
	return len(fake.refreshImageArgsForCall)
}

func (fake *FakeContainerServer) RefreshImageCalls(stub func(string) (lxd.Operation, error)) {
	fake.refreshImageMutex.Lock()
	defer fake.refreshImageMutex.Unlock()
	fake.RefreshImageStub = stub
}

func (fake *FakeContainerServer) RefreshImageArgsForCall(i int) string {
	fake.refreshImageMutex.RLock()
	defer fake.refreshImageMutex.RUnlock()
	argsForCall := fake.refreshImageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) RefreshImageReturns(result1 lxd.Operation, result2 error) {
	fake.refreshImageMutex.Lock()
	defer fake.refreshImageMutex.Unlock()
	fake.RefreshImageStub = nil
	fake.refreshImageReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RefreshImageReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.refreshImageMutex.Lock()
	defer fake.refreshImageMutex.Unlock()
	fake.RefreshImageStub = nil
	if fake.refreshImageReturnsOnCall == nil {
		fake.refreshImageReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.refreshImageReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameClusterGroup(arg1 string, arg2 api.ClusterGroupPost) error {
	fake.renameClusterGroupMutex.Lock()
	ret, specificReturn := fake.renameClusterGroupReturnsOnCall[len(fake.renameClusterGroupArgsForCall)]
	fake.renameClusterGroupArgsForCall = append(fake.renameClusterGroupArgsForCall, struct {
		arg1 string
		arg2 api.ClusterGroupPost
	}{arg1, arg2})
	stub := fake.RenameClusterGroupStub
	fakeReturns := fake.renameClusterGroupReturns
	fake.recordInvocation("RenameClusterGroup", []interface{}{arg1, arg2})
	fake.renameClusterGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameClusterGroupCallCount() int {
	fake.renameClusterGroupMutex.RLock()
	defer fake.renameClusterGroupMutex.RUnlock()
	return len(fake.renameClusterGroupArgsForCall)
}

func (fake *FakeContainerServer) RenameClusterGroupCalls(stub func(string, api.ClusterGroupPost) error) {
	fake.renameClusterGroupMutex.Lock()
	defer fake.renameClusterGroupMutex.Unlock()
	fake.RenameClusterGroupStub = stub
}

func (fake *FakeContainerServer) RenameClusterGroupArgsForCall(i int) (string, api.ClusterGroupPost) {
	fake.renameClusterGroupMutex.RLock()
	defer fake.renameClusterGroupMutex.RUnlock()
	argsForCall := fake.renameClusterGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameClusterGroupReturns(result1 error) {
	fake.renameClusterGroupMutex.Lock()
	defer fake.renameClusterGroupMutex.Unlock()
	fake.RenameClusterGroupStub = nil
	fake.renameClusterGroupReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameClusterGroupReturnsOnCall(i int, result1 error) {
	fake.renameClusterGroupMutex.Lock()
	defer fake.renameClusterGroupMutex.Unlock()
	fake.RenameClusterGroupStub = nil
	if fake.renameClusterGroupReturnsOnCall == nil {
		fake.renameClusterGroupReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameClusterGroupReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameClusterMember(arg1 string, arg2 api.ClusterMemberPost) error {
	fake.renameClusterMemberMutex.Lock()
	ret, specificReturn := fake.renameClusterMemberReturnsOnCall[len(fake.renameClusterMemberArgsForCall)]
	fake.renameClusterMemberArgsForCall = append(fake.renameClusterMemberArgsForCall, struct {
		arg1 string
		arg2 api.ClusterMemberPost
	}{arg1, arg2})
	stub := fake.RenameClusterMemberStub
	fakeReturns := fake.renameClusterMemberReturns
	fake.recordInvocation("RenameClusterMember", []interface{}{arg1, arg2})
	fake.renameClusterMemberMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameClusterMemberCallCount() int {
	fake.renameClusterMemberMutex.RLock()
	defer fake.renameClusterMemberMutex.RUnlock()
	return len(fake.renameClusterMemberArgsForCall)
}

func (fake *FakeContainerServer) RenameClusterMemberCalls(stub func(string, api.ClusterMemberPost) error) {
	fake.renameClusterMemberMutex.Lock()
	defer fake.renameClusterMemberMutex.Unlock()
	fake.RenameClusterMemberStub = stub
}

func (fake *FakeContainerServer) RenameClusterMemberArgsForCall(i int) (string, api.ClusterMemberPost) {
	fake.renameClusterMemberMutex.RLock()
	defer fake.renameClusterMemberMutex.RUnlock()
	argsForCall := fake.renameClusterMemberArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameClusterMemberReturns(result1 error) {
	fake.renameClusterMemberMutex.Lock()
	defer fake.renameClusterMemberMutex.Unlock()
	fake.RenameClusterMemberStub = nil
	fake.renameClusterMemberReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameClusterMemberReturnsOnCall(i int, result1 error) {
	fake.renameClusterMemberMutex.Lock()
	defer fake.renameClusterMemberMutex.Unlock()
	fake.RenameClusterMemberStub = nil
	if fake.renameClusterMemberReturnsOnCall == nil {
		fake.renameClusterMemberReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameClusterMemberReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameContainer(arg1 string, arg2 api.ContainerPost) (lxd.Operation, error) {
	fake.renameContainerMutex.Lock()
	ret, specificReturn := fake.renameContainerReturnsOnCall[len(fake.renameContainerArgsForCall)]
	fake.renameContainerArgsForCall = append(fake.renameContainerArgsForCall, struct {
		arg1 string
		arg2 api.ContainerPost
	}{arg1, arg2})
	stub := fake.RenameContainerStub
	fakeReturns := fake.renameContainerReturns
	fake.recordInvocation("RenameContainer", []interface{}{arg1, arg2})
	fake.renameContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameContainerCallCount() int {
	fake.renameContainerMutex.RLock()
	defer fake.renameContainerMutex.RUnlock()
	return len(fake.renameContainerArgsForCall)
}

func (fake *FakeContainerServer) RenameContainerCalls(stub func(string, api.ContainerPost) (lxd.Operation, error)) {
	fake.renameContainerMutex.Lock()
	defer fake.renameContainerMutex.Unlock()
	fake.RenameContainerStub = stub
}

func (fake *FakeContainerServer) RenameContainerArgsForCall(i int) (string, api.ContainerPost) {
	fake.renameContainerMutex.RLock()
	defer fake.renameContainerMutex.RUnlock()
	argsForCall := fake.renameContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameContainerReturns(result1 lxd.Operation, result2 error) {
	fake.renameContainerMutex.Lock()
	defer fake.renameContainerMutex.Unlock()
	fake.RenameContainerStub = nil
	fake.renameContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameContainerMutex.Lock()
	defer fake.renameContainerMutex.Unlock()
	fake.RenameContainerStub = nil
	if fake.renameContainerReturnsOnCall == nil {
		fake.renameContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameContainerBackup(arg1 string, arg2 string, arg3 api.ContainerBackupPost) (lxd.Operation, error) {
	fake.renameContainerBackupMutex.Lock()
	ret, specificReturn := fake.renameContainerBackupReturnsOnCall[len(fake.renameContainerBackupArgsForCall)]
	fake.renameContainerBackupArgsForCall = append(fake.renameContainerBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.ContainerBackupPost
	}{arg1, arg2, arg3})
	stub := fake.RenameContainerBackupStub
	fakeReturns := fake.renameContainerBackupReturns
	fake.recordInvocation("RenameContainerBackup", []interface{}{arg1, arg2, arg3})
	fake.renameContainerBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameContainerBackupCallCount() int {
	fake.renameContainerBackupMutex.RLock()
	defer fake.renameContainerBackupMutex.RUnlock()
	return len(fake.renameContainerBackupArgsForCall)
}

func (fake *FakeContainerServer) RenameContainerBackupCalls(stub func(string, string, api.ContainerBackupPost) (lxd.Operation, error)) {
	fake.renameContainerBackupMutex.Lock()
	defer fake.renameContainerBackupMutex.Unlock()
	fake.RenameContainerBackupStub = stub
}

func (fake *FakeContainerServer) RenameContainerBackupArgsForCall(i int) (string, string, api.ContainerBackupPost) {
	fake.renameContainerBackupMutex.RLock()
	defer fake.renameContainerBackupMutex.RUnlock()
	argsForCall := fake.renameContainerBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) RenameContainerBackupReturns(result1 lxd.Operation, result2 error) {
	fake.renameContainerBackupMutex.Lock()
	defer fake.renameContainerBackupMutex.Unlock()
	fake.RenameContainerBackupStub = nil
	fake.renameContainerBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameContainerBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameContainerBackupMutex.Lock()
	defer fake.renameContainerBackupMutex.Unlock()
	fake.RenameContainerBackupStub = nil
	if fake.renameContainerBackupReturnsOnCall == nil {
		fake.renameContainerBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameContainerBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameContainerSnapshot(arg1 string, arg2 string, arg3 api.ContainerSnapshotPost) (lxd.Operation, error) {
	fake.renameContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.renameContainerSnapshotReturnsOnCall[len(fake.renameContainerSnapshotArgsForCall)]
	fake.renameContainerSnapshotArgsForCall = append(fake.renameContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPost
	}{arg1, arg2, arg3})
	stub := fake.RenameContainerSnapshotStub
	fakeReturns := fake.renameContainerSnapshotReturns
	fake.recordInvocation("RenameContainerSnapshot", []interface{}{arg1, arg2, arg3})
	fake.renameContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameContainerSnapshotCallCount() int {
	fake.renameContainerSnapshotMutex.RLock()
	defer fake.renameContainerSnapshotMutex.RUnlock()
	return len(fake.renameContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) RenameContainerSnapshotCalls(stub func(string, string, api.ContainerSnapshotPost) (lxd.Operation, error)) {
	fake.renameContainerSnapshotMutex.Lock()
	defer fake.renameContainerSnapshotMutex.Unlock()
	fake.RenameContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) RenameContainerSnapshotArgsForCall(i int) (string, string, api.ContainerSnapshotPost) {
	fake.renameContainerSnapshotMutex.RLock()
	defer fake.renameContainerSnapshotMutex.RUnlock()
	argsForCall := fake.renameContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) RenameContainerSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.renameContainerSnapshotMutex.Lock()
	defer fake.renameContainerSnapshotMutex.Unlock()
	fake.RenameContainerSnapshotStub = nil
	fake.renameContainerSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameContainerSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameContainerSnapshotMutex.Lock()
	defer fake.renameContainerSnapshotMutex.Unlock()
	fake.RenameContainerSnapshotStub = nil
	if fake.renameContainerSnapshotReturnsOnCall == nil {
		fake.renameContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameImageAlias(arg1 string, arg2 api.ImageAliasesEntryPost) error {
	fake.renameImageAliasMutex.Lock()
	ret, specificReturn := fake.renameImageAliasReturnsOnCall[len(fake.renameImageAliasArgsForCall)]
	fake.renameImageAliasArgsForCall = append(fake.renameImageAliasArgsForCall, struct {
		arg1 string
		arg2 api.ImageAliasesEntryPost
	}{arg1, arg2})
	stub := fake.RenameImageAliasStub
	fakeReturns := fake.renameImageAliasReturns
	fake.recordInvocation("RenameImageAlias", []interface{}{arg1, arg2})
	fake.renameImageAliasMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameImageAliasCallCount() int {
	fake.renameImageAliasMutex.RLock()
	defer fake.renameImageAliasMutex.RUnlock()
	return len(fake.renameImageAliasArgsForCall)
}

func (fake *FakeContainerServer) RenameImageAliasCalls(stub func(string, api.ImageAliasesEntryPost) error) {
	fake.renameImageAliasMutex.Lock()
	defer fake.renameImageAliasMutex.Unlock()
	fake.RenameImageAliasStub = stub
}

func (fake *FakeContainerServer) RenameImageAliasArgsForCall(i int) (string, api.ImageAliasesEntryPost) {
	fake.renameImageAliasMutex.RLock()
	defer fake.renameImageAliasMutex.RUnlock()
	argsForCall := fake.renameImageAliasArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameImageAliasReturns(result1 error) {
	fake.renameImageAliasMutex.Lock()
	defer fake.renameImageAliasMutex.Unlock()
	fake.RenameImageAliasStub = nil
	fake.renameImageAliasReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameImageAliasReturnsOnCall(i int, result1 error) {
	fake.renameImageAliasMutex.Lock()
	defer fake.renameImageAliasMutex.Unlock()
	fake.RenameImageAliasStub = nil
	if fake.renameImageAliasReturnsOnCall == nil {
		fake.renameImageAliasReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameImageAliasReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameInstance(arg1 string, arg2 api.InstancePost) (lxd.Operation, error) {
	fake.renameInstanceMutex.Lock()
	ret, specificReturn := fake.renameInstanceReturnsOnCall[len(fake.renameInstanceArgsForCall)]
	fake.renameInstanceArgsForCall = append(fake.renameInstanceArgsForCall, struct {
		arg1 string
		arg2 api.InstancePost
	}{arg1, arg2})
	stub := fake.RenameInstanceStub
	fakeReturns := fake.renameInstanceReturns
	fake.recordInvocation("RenameInstance", []interface{}{arg1, arg2})
	fake.renameInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameInstanceCallCount() int {
	fake.renameInstanceMutex.RLock()
	defer fake.renameInstanceMutex.RUnlock()
	return len(fake.renameInstanceArgsForCall)
}

func (fake *FakeContainerServer) RenameInstanceCalls(stub func(string, api.InstancePost) (lxd.Operation, error)) {
	fake.renameInstanceMutex.Lock()
	defer fake.renameInstanceMutex.Unlock()
	fake.RenameInstanceStub = stub
}

func (fake *FakeContainerServer) RenameInstanceArgsForCall(i int) (string, api.InstancePost) {
	fake.renameInstanceMutex.RLock()
	defer fake.renameInstanceMutex.RUnlock()
	argsForCall := fake.renameInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.renameInstanceMutex.Lock()
	defer fake.renameInstanceMutex.Unlock()
	fake.RenameInstanceStub = nil
	fake.renameInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameInstanceMutex.Lock()
	defer fake.renameInstanceMutex.Unlock()
	fake.RenameInstanceStub = nil
	if fake.renameInstanceReturnsOnCall == nil {
		fake.renameInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameInstanceBackup(arg1 string, arg2 string, arg3 api.InstanceBackupPost) (lxd.Operation, error) {
	fake.renameInstanceBackupMutex.Lock()
	ret, specificReturn := fake.renameInstanceBackupReturnsOnCall[len(fake.renameInstanceBackupArgsForCall)]
	fake.renameInstanceBackupArgsForCall = append(fake.renameInstanceBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.InstanceBackupPost
	}{arg1, arg2, arg3})
	stub := fake.RenameInstanceBackupStub
	fakeReturns := fake.renameInstanceBackupReturns
	fake.recordInvocation("RenameInstanceBackup", []interface{}{arg1, arg2, arg3})
	fake.renameInstanceBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameInstanceBackupCallCount() int {
	fake.renameInstanceBackupMutex.RLock()
	defer fake.renameInstanceBackupMutex.RUnlock()
	return len(fake.renameInstanceBackupArgsForCall)
}

func (fake *FakeContainerServer) RenameInstanceBackupCalls(stub func(string, string, api.InstanceBackupPost) (lxd.Operation, error)) {
	fake.renameInstanceBackupMutex.Lock()
	defer fake.renameInstanceBackupMutex.Unlock()
	fake.RenameInstanceBackupStub = stub
}

func (fake *FakeContainerServer) RenameInstanceBackupArgsForCall(i int) (string, string, api.InstanceBackupPost) {
	fake.renameInstanceBackupMutex.RLock()
	defer fake.renameInstanceBackupMutex.RUnlock()
	argsForCall := fake.renameInstanceBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) RenameInstanceBackupReturns(result1 lxd.Operation, result2 error) {
	fake.renameInstanceBackupMutex.Lock()
	defer fake.renameInstanceBackupMutex.Unlock()
	fake.RenameInstanceBackupStub = nil
	fake.renameInstanceBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameInstanceBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameInstanceBackupMutex.Lock()
	defer fake.renameInstanceBackupMutex.Unlock()
	fake.RenameInstanceBackupStub = nil
	if fake.renameInstanceBackupReturnsOnCall == nil {
		fake.renameInstanceBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameInstanceBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameInstanceSnapshot(arg1 string, arg2 string, arg3 api.InstanceSnapshotPost) (lxd.Operation, error) {
	fake.renameInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.renameInstanceSnapshotReturnsOnCall[len(fake.renameInstanceSnapshotArgsForCall)]
	fake.renameInstanceSnapshotArgsForCall = append(fake.renameInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPost
	}{arg1, arg2, arg3})
	stub := fake.RenameInstanceSnapshotStub
	fakeReturns := fake.renameInstanceSnapshotReturns
	fake.recordInvocation("RenameInstanceSnapshot", []interface{}{arg1, arg2, arg3})
	fake.renameInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameInstanceSnapshotCallCount() int {
	fake.renameInstanceSnapshotMutex.RLock()
	defer fake.renameInstanceSnapshotMutex.RUnlock()
	return len(fake.renameInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) RenameInstanceSnapshotCalls(stub func(string, string, api.InstanceSnapshotPost) (lxd.Operation, error)) {
	fake.renameInstanceSnapshotMutex.Lock()
	defer fake.renameInstanceSnapshotMutex.Unlock()
	fake.RenameInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) RenameInstanceSnapshotArgsForCall(i int) (string, string, api.InstanceSnapshotPost) {
	fake.renameInstanceSnapshotMutex.RLock()
	defer fake.renameInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.renameInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) RenameInstanceSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.renameInstanceSnapshotMutex.Lock()
	defer fake.renameInstanceSnapshotMutex.Unlock()
	fake.RenameInstanceSnapshotStub = nil
	fake.renameInstanceSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameInstanceSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameInstanceSnapshotMutex.Lock()
	defer fake.renameInstanceSnapshotMutex.Unlock()
	fake.RenameInstanceSnapshotStub = nil
	if fake.renameInstanceSnapshotReturnsOnCall == nil {
		fake.renameInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameNetwork(arg1 string, arg2 api.NetworkPost) error {
	fake.renameNetworkMutex.Lock()
	ret, specificReturn := fake.renameNetworkReturnsOnCall[len(fake.renameNetworkArgsForCall)]
	fake.renameNetworkArgsForCall = append(fake.renameNetworkArgsForCall, struct {
		arg1 string
		arg2 api.NetworkPost
	}{arg1, arg2})
	stub := fake.RenameNetworkStub
	fakeReturns := fake.renameNetworkReturns
	fake.recordInvocation("RenameNetwork", []interface{}{arg1, arg2})
	fake.renameNetworkMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameNetworkCallCount() int {
	fake.renameNetworkMutex.RLock()
	defer fake.renameNetworkMutex.RUnlock()
	return len(fake.renameNetworkArgsForCall)
}

func (fake *FakeContainerServer) RenameNetworkCalls(stub func(string, api.NetworkPost) error) {
	fake.renameNetworkMutex.Lock()
	defer fake.renameNetworkMutex.Unlock()
	fake.RenameNetworkStub = stub
}

func (fake *FakeContainerServer) RenameNetworkArgsForCall(i int) (string, api.NetworkPost) {
	fake.renameNetworkMutex.RLock()
	defer fake.renameNetworkMutex.RUnlock()
	argsForCall := fake.renameNetworkArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameNetworkReturns(result1 error) {
	fake.renameNetworkMutex.Lock()
	defer fake.renameNetworkMutex.Unlock()
	fake.RenameNetworkStub = nil
	fake.renameNetworkReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameNetworkReturnsOnCall(i int, result1 error) {
	fake.renameNetworkMutex.Lock()
	defer fake.renameNetworkMutex.Unlock()
	fake.RenameNetworkStub = nil
	if fake.renameNetworkReturnsOnCall == nil {
		fake.renameNetworkReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameNetworkReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameNetworkACL(arg1 string, arg2 api.NetworkACLPost) error {
	fake.renameNetworkACLMutex.Lock()
	ret, specificReturn := fake.renameNetworkACLReturnsOnCall[len(fake.renameNetworkACLArgsForCall)]
	fake.renameNetworkACLArgsForCall = append(fake.renameNetworkACLArgsForCall, struct {
		arg1 string
		arg2 api.NetworkACLPost
	}{arg1, arg2})
	stub := fake.RenameNetworkACLStub
	fakeReturns := fake.renameNetworkACLReturns
	fake.recordInvocation("RenameNetworkACL", []interface{}{arg1, arg2})
	fake.renameNetworkACLMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameNetworkACLCallCount() int {
	fake.renameNetworkACLMutex.RLock()
	defer fake.renameNetworkACLMutex.RUnlock()
	return len(fake.renameNetworkACLArgsForCall)
}

func (fake *FakeContainerServer) RenameNetworkACLCalls(stub func(string, api.NetworkACLPost) error) {
	fake.renameNetworkACLMutex.Lock()
	defer fake.renameNetworkACLMutex.Unlock()
	fake.RenameNetworkACLStub = stub
}

func (fake *FakeContainerServer) RenameNetworkACLArgsForCall(i int) (string, api.NetworkACLPost) {
	fake.renameNetworkACLMutex.RLock()
	defer fake.renameNetworkACLMutex.RUnlock()
	argsForCall := fake.renameNetworkACLArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameNetworkACLReturns(result1 error) {
	fake.renameNetworkACLMutex.Lock()
	defer fake.renameNetworkACLMutex.Unlock()
	fake.RenameNetworkACLStub = nil
	fake.renameNetworkACLReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameNetworkACLReturnsOnCall(i int, result1 error) {
	fake.renameNetworkACLMutex.Lock()
	defer fake.renameNetworkACLMutex.Unlock()
	fake.RenameNetworkACLStub = nil
	if fake.renameNetworkACLReturnsOnCall == nil {
		fake.renameNetworkACLReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameNetworkACLReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameProfile(arg1 string, arg2 api.ProfilePost) error {
	fake.renameProfileMutex.Lock()
	ret, specificReturn := fake.renameProfileReturnsOnCall[len(fake.renameProfileArgsForCall)]
	fake.renameProfileArgsForCall = append(fake.renameProfileArgsForCall, struct {
		arg1 string
		arg2 api.ProfilePost
	}{arg1, arg2})
	stub := fake.RenameProfileStub
	fakeReturns := fake.renameProfileReturns
	fake.recordInvocation("RenameProfile", []interface{}{arg1, arg2})
	fake.renameProfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameProfileCallCount() int {
	fake.renameProfileMutex.RLock()
	defer fake.renameProfileMutex.RUnlock()
	return len(fake.renameProfileArgsForCall)
}

func (fake *FakeContainerServer) RenameProfileCalls(stub func(string, api.ProfilePost) error) {
	fake.renameProfileMutex.Lock()
	defer fake.renameProfileMutex.Unlock()
	fake.RenameProfileStub = stub
}

func (fake *FakeContainerServer) RenameProfileArgsForCall(i int) (string, api.ProfilePost) {
	fake.renameProfileMutex.RLock()
	defer fake.renameProfileMutex.RUnlock()
	argsForCall := fake.renameProfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameProfileReturns(result1 error) {
	fake.renameProfileMutex.Lock()
	defer fake.renameProfileMutex.Unlock()
	fake.RenameProfileStub = nil
	fake.renameProfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameProfileReturnsOnCall(i int, result1 error) {
	fake.renameProfileMutex.Lock()
	defer fake.renameProfileMutex.Unlock()
	fake.RenameProfileStub = nil
	if fake.renameProfileReturnsOnCall == nil {
		fake.renameProfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameProfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameProject(arg1 string, arg2 api.ProjectPost) (lxd.Operation, error) {
	fake.renameProjectMutex.Lock()
	ret, specificReturn := fake.renameProjectReturnsOnCall[len(fake.renameProjectArgsForCall)]
	fake.renameProjectArgsForCall = append(fake.renameProjectArgsForCall, struct {
		arg1 string
		arg2 api.ProjectPost
	}{arg1, arg2})
	stub := fake.RenameProjectStub
	fakeReturns := fake.renameProjectReturns
	fake.recordInvocation("RenameProject", []interface{}{arg1, arg2})
	fake.renameProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameProjectCallCount() int {
	fake.renameProjectMutex.RLock()
	defer fake.renameProjectMutex.RUnlock()
	return len(fake.renameProjectArgsForCall)
}

func (fake *FakeContainerServer) RenameProjectCalls(stub func(string, api.ProjectPost) (lxd.Operation, error)) {
	fake.renameProjectMutex.Lock()
	defer fake.renameProjectMutex.Unlock()
	fake.RenameProjectStub = stub
}

func (fake *FakeContainerServer) RenameProjectArgsForCall(i int) (string, api.ProjectPost) {
	fake.renameProjectMutex.RLock()
	defer fake.renameProjectMutex.RUnlock()
	argsForCall := fake.renameProjectArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) RenameProjectReturns(result1 lxd.Operation, result2 error) {
	fake.renameProjectMutex.Lock()
	defer fake.renameProjectMutex.Unlock()
	fake.RenameProjectStub = nil
	fake.renameProjectReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameProjectReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameProjectMutex.Lock()
	defer fake.renameProjectMutex.Unlock()
	fake.RenameProjectStub = nil
	if fake.renameProjectReturnsOnCall == nil {
		fake.renameProjectReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameProjectReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameStoragePoolVolume(arg1 string, arg2 string, arg3 string, arg4 api.StorageVolumePost) error {
	fake.renameStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.renameStoragePoolVolumeReturnsOnCall[len(fake.renameStoragePoolVolumeArgsForCall)]
	fake.renameStoragePoolVolumeArgsForCall = append(fake.renameStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumePost
	}{arg1, arg2, arg3, arg4})
	stub := fake.RenameStoragePoolVolumeStub
	fakeReturns := fake.renameStoragePoolVolumeReturns
	fake.recordInvocation("RenameStoragePoolVolume", []interface{}{arg1, arg2, arg3, arg4})
	fake.renameStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeCallCount() int {
	fake.renameStoragePoolVolumeMutex.RLock()
	defer fake.renameStoragePoolVolumeMutex.RUnlock()
	return len(fake.renameStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeCalls(stub func(string, string, string, api.StorageVolumePost) error) {
	fake.renameStoragePoolVolumeMutex.Lock()
	defer fake.renameStoragePoolVolumeMutex.Unlock()
	fake.RenameStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeArgsForCall(i int) (string, string, string, api.StorageVolumePost) {
	fake.renameStoragePoolVolumeMutex.RLock()
	defer fake.renameStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.renameStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeReturns(result1 error) {
	fake.renameStoragePoolVolumeMutex.Lock()
	defer fake.renameStoragePoolVolumeMutex.Unlock()
	fake.RenameStoragePoolVolumeStub = nil
	fake.renameStoragePoolVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeReturnsOnCall(i int, result1 error) {
	fake.renameStoragePoolVolumeMutex.Lock()
	defer fake.renameStoragePoolVolumeMutex.Unlock()
	fake.RenameStoragePoolVolumeStub = nil
	if fake.renameStoragePoolVolumeReturnsOnCall == nil {
		fake.renameStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackup(arg1 string, arg2 string, arg3 string, arg4 api.StoragePoolVolumeBackupPost) (lxd.Operation, error) {
	fake.renameStoragePoolVolumeBackupMutex.Lock()
	ret, specificReturn := fake.renameStoragePoolVolumeBackupReturnsOnCall[len(fake.renameStoragePoolVolumeBackupArgsForCall)]
	fake.renameStoragePoolVolumeBackupArgsForCall = append(fake.renameStoragePoolVolumeBackupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StoragePoolVolumeBackupPost
	}{arg1, arg2, arg3, arg4})
	stub := fake.RenameStoragePoolVolumeBackupStub
	fakeReturns := fake.renameStoragePoolVolumeBackupReturns
	fake.recordInvocation("RenameStoragePoolVolumeBackup", []interface{}{arg1, arg2, arg3, arg4})
	fake.renameStoragePoolVolumeBackupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackupCallCount() int {
	fake.renameStoragePoolVolumeBackupMutex.RLock()
	defer fake.renameStoragePoolVolumeBackupMutex.RUnlock()
	return len(fake.renameStoragePoolVolumeBackupArgsForCall)
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackupCalls(stub func(string, string, string, api.StoragePoolVolumeBackupPost) (lxd.Operation, error)) {
	fake.renameStoragePoolVolumeBackupMutex.Lock()
	defer fake.renameStoragePoolVolumeBackupMutex.Unlock()
	fake.RenameStoragePoolVolumeBackupStub = stub
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackupArgsForCall(i int) (string, string, string, api.StoragePoolVolumeBackupPost) {
	fake.renameStoragePoolVolumeBackupMutex.RLock()
	defer fake.renameStoragePoolVolumeBackupMutex.RUnlock()
	argsForCall := fake.renameStoragePoolVolumeBackupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackupReturns(result1 lxd.Operation, result2 error) {
	fake.renameStoragePoolVolumeBackupMutex.Lock()
	defer fake.renameStoragePoolVolumeBackupMutex.Unlock()
	fake.RenameStoragePoolVolumeBackupStub = nil
	fake.renameStoragePoolVolumeBackupReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeBackupReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameStoragePoolVolumeBackupMutex.Lock()
	defer fake.renameStoragePoolVolumeBackupMutex.Unlock()
	fake.RenameStoragePoolVolumeBackupStub = nil
	if fake.renameStoragePoolVolumeBackupReturnsOnCall == nil {
		fake.renameStoragePoolVolumeBackupReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameStoragePoolVolumeBackupReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshot(arg1 string, arg2 string, arg3 string, arg4 string, arg5 api.StorageVolumeSnapshotPost) (lxd.Operation, error) {
	fake.renameStoragePoolVolumeSnapshotMutex.Lock()
	ret, specificReturn := fake.renameStoragePoolVolumeSnapshotReturnsOnCall[len(fake.renameStoragePoolVolumeSnapshotArgsForCall)]
	fake.renameStoragePoolVolumeSnapshotArgsForCall = append(fake.renameStoragePoolVolumeSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 api.StorageVolumeSnapshotPost
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.RenameStoragePoolVolumeSnapshotStub
	fakeReturns := fake.renameStoragePoolVolumeSnapshotReturns
	fake.recordInvocation("RenameStoragePoolVolumeSnapshot", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.renameStoragePoolVolumeSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshotCallCount() int {
	fake.renameStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.RUnlock()
	return len(fake.renameStoragePoolVolumeSnapshotArgsForCall)
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshotCalls(stub func(string, string, string, string, api.StorageVolumeSnapshotPost) (lxd.Operation, error)) {
	fake.renameStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.Unlock()
	fake.RenameStoragePoolVolumeSnapshotStub = stub
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshotArgsForCall(i int) (string, string, string, string, api.StorageVolumeSnapshotPost) {
	fake.renameStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.RUnlock()
	argsForCall := fake.renameStoragePoolVolumeSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.renameStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.Unlock()
	fake.RenameStoragePoolVolumeSnapshotStub = nil
	fake.renameStoragePoolVolumeSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RenameStoragePoolVolumeSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.renameStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.Unlock()
	fake.RenameStoragePoolVolumeSnapshotStub = nil
	if fake.renameStoragePoolVolumeSnapshotReturnsOnCall == nil {
		fake.renameStoragePoolVolumeSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.renameStoragePoolVolumeSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) RequireAuthenticated(arg1 bool) {
	fake.requireAuthenticatedMutex.Lock()
	fake.requireAuthenticatedArgsForCall = append(fake.requireAuthenticatedArgsForCall, struct {
		arg1 bool
	}{arg1})
	stub := fake.RequireAuthenticatedStub
	fake.recordInvocation("RequireAuthenticated", []interface{}{arg1})
	fake.requireAuthenticatedMutex.Unlock()
	if stub != nil {
		fake.RequireAuthenticatedStub(arg1)
	}
}

func (fake *FakeContainerServer) RequireAuthenticatedCallCount() int {
	fake.requireAuthenticatedMutex.RLock()
	defer fake.requireAuthenticatedMutex.RUnlock()
	return len(fake.requireAuthenticatedArgsForCall)
}

func (fake *FakeContainerServer) RequireAuthenticatedCalls(stub func(bool)) {
	fake.requireAuthenticatedMutex.Lock()
	defer fake.requireAuthenticatedMutex.Unlock()
	fake.RequireAuthenticatedStub = stub
}

func (fake *FakeContainerServer) RequireAuthenticatedArgsForCall(i int) bool {
	fake.requireAuthenticatedMutex.RLock()
	defer fake.requireAuthenticatedMutex.RUnlock()
	argsForCall := fake.requireAuthenticatedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) SendEvent(arg1 api.Event) error {
	fake.sendEventMutex.Lock()
	ret, specificReturn := fake.sendEventReturnsOnCall[len(fake.sendEventArgsForCall)]
	fake.sendEventArgsForCall = append(fake.sendEventArgsForCall, struct {
		arg1 api.Event
	}{arg1})
	stub := fake.SendEventStub
	fakeReturns := fake.sendEventReturns
	fake.recordInvocation("SendEvent", []interface{}{arg1})
	fake.sendEventMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) SendEventCallCount() int {
	fake.sendEventMutex.RLock()
	defer fake.sendEventMutex.RUnlock()
	return len(fake.sendEventArgsForCall)
}

func (fake *FakeContainerServer) SendEventCalls(stub func(api.Event) error) {
	fake.sendEventMutex.Lock()
	defer fake.sendEventMutex.Unlock()
	fake.SendEventStub = stub
}

func (fake *FakeContainerServer) SendEventArgsForCall(i int) api.Event {
	fake.sendEventMutex.RLock()
	defer fake.sendEventMutex.RUnlock()
	argsForCall := fake.sendEventArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) SendEventReturns(result1 error) {
	fake.sendEventMutex.Lock()
	defer fake.sendEventMutex.Unlock()
	fake.SendEventStub = nil
	fake.sendEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) SendEventReturnsOnCall(i int, result1 error) {
	fake.sendEventMutex.Lock()
	defer fake.sendEventMutex.Unlock()
	fake.SendEventStub = nil
	if fake.sendEventReturnsOnCall == nil {
		fake.sendEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.sendEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) SetContainerMetadata(arg1 string, arg2 api.ImageMetadata, arg3 string) error {
	fake.setContainerMetadataMutex.Lock()
	ret, specificReturn := fake.setContainerMetadataReturnsOnCall[len(fake.setContainerMetadataArgsForCall)]
	fake.setContainerMetadataArgsForCall = append(fake.setContainerMetadataArgsForCall, struct {
		arg1 string
		arg2 api.ImageMetadata
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.SetContainerMetadataStub
	fakeReturns := fake.setContainerMetadataReturns
	fake.recordInvocation("SetContainerMetadata", []interface{}{arg1, arg2, arg3})
	fake.setContainerMetadataMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) SetContainerMetadataCallCount() int {
	fake.setContainerMetadataMutex.RLock()
	defer fake.setContainerMetadataMutex.RUnlock()
	return len(fake.setContainerMetadataArgsForCall)
}

func (fake *FakeContainerServer) SetContainerMetadataCalls(stub func(string, api.ImageMetadata, string) error) {
	fake.setContainerMetadataMutex.Lock()
	defer fake.setContainerMetadataMutex.Unlock()
	fake.SetContainerMetadataStub = stub
}

func (fake *FakeContainerServer) SetContainerMetadataArgsForCall(i int) (string, api.ImageMetadata, string) {
	fake.setContainerMetadataMutex.RLock()
	defer fake.setContainerMetadataMutex.RUnlock()
	argsForCall := fake.setContainerMetadataArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) SetContainerMetadataReturns(result1 error) {
	fake.setContainerMetadataMutex.Lock()
	defer fake.setContainerMetadataMutex.Unlock()
	fake.SetContainerMetadataStub = nil
	fake.setContainerMetadataReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) SetContainerMetadataReturnsOnCall(i int, result1 error) {
	fake.setContainerMetadataMutex.Lock()
	defer fake.setContainerMetadataMutex.Unlock()
	fake.SetContainerMetadataStub = nil
	if fake.setContainerMetadataReturnsOnCall == nil {
		fake.setContainerMetadataReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setContainerMetadataReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateCertificate(arg1 string, arg2 api.CertificatePut, arg3 string) error {
	fake.updateCertificateMutex.Lock()
	ret, specificReturn := fake.updateCertificateReturnsOnCall[len(fake.updateCertificateArgsForCall)]
	fake.updateCertificateArgsForCall = append(fake.updateCertificateArgsForCall, struct {
		arg1 string
		arg2 api.CertificatePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateCertificateStub
	fakeReturns := fake.updateCertificateReturns
	fake.recordInvocation("UpdateCertificate", []interface{}{arg1, arg2, arg3})
	fake.updateCertificateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateCertificateCallCount() int {
	fake.updateCertificateMutex.RLock()
	defer fake.updateCertificateMutex.RUnlock()
	return len(fake.updateCertificateArgsForCall)
}

func (fake *FakeContainerServer) UpdateCertificateCalls(stub func(string, api.CertificatePut, string) error) {
	fake.updateCertificateMutex.Lock()
	defer fake.updateCertificateMutex.Unlock()
	fake.UpdateCertificateStub = stub
}

func (fake *FakeContainerServer) UpdateCertificateArgsForCall(i int) (string, api.CertificatePut, string) {
	fake.updateCertificateMutex.RLock()
	defer fake.updateCertificateMutex.RUnlock()
	argsForCall := fake.updateCertificateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateCertificateReturns(result1 error) {
	fake.updateCertificateMutex.Lock()
	defer fake.updateCertificateMutex.Unlock()
	fake.UpdateCertificateStub = nil
	fake.updateCertificateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateCertificateReturnsOnCall(i int, result1 error) {
	fake.updateCertificateMutex.Lock()
	defer fake.updateCertificateMutex.Unlock()
	fake.UpdateCertificateStub = nil
	if fake.updateCertificateReturnsOnCall == nil {
		fake.updateCertificateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateCertificateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateCluster(arg1 api.ClusterPut, arg2 string) (lxd.Operation, error) {
	fake.updateClusterMutex.Lock()
	ret, specificReturn := fake.updateClusterReturnsOnCall[len(fake.updateClusterArgsForCall)]
	fake.updateClusterArgsForCall = append(fake.updateClusterArgsForCall, struct {
		arg1 api.ClusterPut
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateClusterStub
	fakeReturns := fake.updateClusterReturns
	fake.recordInvocation("UpdateCluster", []interface{}{arg1, arg2})
	fake.updateClusterMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateClusterCallCount() int {
	fake.updateClusterMutex.RLock()
	defer fake.updateClusterMutex.RUnlock()
	return len(fake.updateClusterArgsForCall)
}

func (fake *FakeContainerServer) UpdateClusterCalls(stub func(api.ClusterPut, string) (lxd.Operation, error)) {
	fake.updateClusterMutex.Lock()
	defer fake.updateClusterMutex.Unlock()
	fake.UpdateClusterStub = stub
}

func (fake *FakeContainerServer) UpdateClusterArgsForCall(i int) (api.ClusterPut, string) {
	fake.updateClusterMutex.RLock()
	defer fake.updateClusterMutex.RUnlock()
	argsForCall := fake.updateClusterArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) UpdateClusterReturns(result1 lxd.Operation, result2 error) {
	fake.updateClusterMutex.Lock()
	defer fake.updateClusterMutex.Unlock()
	fake.UpdateClusterStub = nil
	fake.updateClusterReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateClusterReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateClusterMutex.Lock()
	defer fake.updateClusterMutex.Unlock()
	fake.UpdateClusterStub = nil
	if fake.updateClusterReturnsOnCall == nil {
		fake.updateClusterReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateClusterReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateClusterCertificate(arg1 api.ClusterCertificatePut, arg2 string) error {
	fake.updateClusterCertificateMutex.Lock()
	ret, specificReturn := fake.updateClusterCertificateReturnsOnCall[len(fake.updateClusterCertificateArgsForCall)]
	fake.updateClusterCertificateArgsForCall = append(fake.updateClusterCertificateArgsForCall, struct {
		arg1 api.ClusterCertificatePut
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateClusterCertificateStub
	fakeReturns := fake.updateClusterCertificateReturns
	fake.recordInvocation("UpdateClusterCertificate", []interface{}{arg1, arg2})
	fake.updateClusterCertificateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateClusterCertificateCallCount() int {
	fake.updateClusterCertificateMutex.RLock()
	defer fake.updateClusterCertificateMutex.RUnlock()
	return len(fake.updateClusterCertificateArgsForCall)
}

func (fake *FakeContainerServer) UpdateClusterCertificateCalls(stub func(api.ClusterCertificatePut, string) error) {
	fake.updateClusterCertificateMutex.Lock()
	defer fake.updateClusterCertificateMutex.Unlock()
	fake.UpdateClusterCertificateStub = stub
}

func (fake *FakeContainerServer) UpdateClusterCertificateArgsForCall(i int) (api.ClusterCertificatePut, string) {
	fake.updateClusterCertificateMutex.RLock()
	defer fake.updateClusterCertificateMutex.RUnlock()
	argsForCall := fake.updateClusterCertificateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) UpdateClusterCertificateReturns(result1 error) {
	fake.updateClusterCertificateMutex.Lock()
	defer fake.updateClusterCertificateMutex.Unlock()
	fake.UpdateClusterCertificateStub = nil
	fake.updateClusterCertificateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterCertificateReturnsOnCall(i int, result1 error) {
	fake.updateClusterCertificateMutex.Lock()
	defer fake.updateClusterCertificateMutex.Unlock()
	fake.UpdateClusterCertificateStub = nil
	if fake.updateClusterCertificateReturnsOnCall == nil {
		fake.updateClusterCertificateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateClusterCertificateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterGroup(arg1 string, arg2 api.ClusterGroupPut, arg3 string) error {
	fake.updateClusterGroupMutex.Lock()
	ret, specificReturn := fake.updateClusterGroupReturnsOnCall[len(fake.updateClusterGroupArgsForCall)]
	fake.updateClusterGroupArgsForCall = append(fake.updateClusterGroupArgsForCall, struct {
		arg1 string
		arg2 api.ClusterGroupPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateClusterGroupStub
	fakeReturns := fake.updateClusterGroupReturns
	fake.recordInvocation("UpdateClusterGroup", []interface{}{arg1, arg2, arg3})
	fake.updateClusterGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateClusterGroupCallCount() int {
	fake.updateClusterGroupMutex.RLock()
	defer fake.updateClusterGroupMutex.RUnlock()
	return len(fake.updateClusterGroupArgsForCall)
}

func (fake *FakeContainerServer) UpdateClusterGroupCalls(stub func(string, api.ClusterGroupPut, string) error) {
	fake.updateClusterGroupMutex.Lock()
	defer fake.updateClusterGroupMutex.Unlock()
	fake.UpdateClusterGroupStub = stub
}

func (fake *FakeContainerServer) UpdateClusterGroupArgsForCall(i int) (string, api.ClusterGroupPut, string) {
	fake.updateClusterGroupMutex.RLock()
	defer fake.updateClusterGroupMutex.RUnlock()
	argsForCall := fake.updateClusterGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateClusterGroupReturns(result1 error) {
	fake.updateClusterGroupMutex.Lock()
	defer fake.updateClusterGroupMutex.Unlock()
	fake.UpdateClusterGroupStub = nil
	fake.updateClusterGroupReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterGroupReturnsOnCall(i int, result1 error) {
	fake.updateClusterGroupMutex.Lock()
	defer fake.updateClusterGroupMutex.Unlock()
	fake.UpdateClusterGroupStub = nil
	if fake.updateClusterGroupReturnsOnCall == nil {
		fake.updateClusterGroupReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateClusterGroupReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterMember(arg1 string, arg2 api.ClusterMemberPut, arg3 string) error {
	fake.updateClusterMemberMutex.Lock()
	ret, specificReturn := fake.updateClusterMemberReturnsOnCall[len(fake.updateClusterMemberArgsForCall)]
	fake.updateClusterMemberArgsForCall = append(fake.updateClusterMemberArgsForCall, struct {
		arg1 string
		arg2 api.ClusterMemberPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateClusterMemberStub
	fakeReturns := fake.updateClusterMemberReturns
	fake.recordInvocation("UpdateClusterMember", []interface{}{arg1, arg2, arg3})
	fake.updateClusterMemberMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateClusterMemberCallCount() int {
	fake.updateClusterMemberMutex.RLock()
	defer fake.updateClusterMemberMutex.RUnlock()
	return len(fake.updateClusterMemberArgsForCall)
}

func (fake *FakeContainerServer) UpdateClusterMemberCalls(stub func(string, api.ClusterMemberPut, string) error) {
	fake.updateClusterMemberMutex.Lock()
	defer fake.updateClusterMemberMutex.Unlock()
	fake.UpdateClusterMemberStub = stub
}

func (fake *FakeContainerServer) UpdateClusterMemberArgsForCall(i int) (string, api.ClusterMemberPut, string) {
	fake.updateClusterMemberMutex.RLock()
	defer fake.updateClusterMemberMutex.RUnlock()
	argsForCall := fake.updateClusterMemberArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateClusterMemberReturns(result1 error) {
	fake.updateClusterMemberMutex.Lock()
	defer fake.updateClusterMemberMutex.Unlock()
	fake.UpdateClusterMemberStub = nil
	fake.updateClusterMemberReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterMemberReturnsOnCall(i int, result1 error) {
	fake.updateClusterMemberMutex.Lock()
	defer fake.updateClusterMemberMutex.Unlock()
	fake.UpdateClusterMemberStub = nil
	if fake.updateClusterMemberReturnsOnCall == nil {
		fake.updateClusterMemberReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateClusterMemberReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateClusterMemberState(arg1 string, arg2 api.ClusterMemberStatePost) (lxd.Operation, error) {
	fake.updateClusterMemberStateMutex.Lock()
	ret, specificReturn := fake.updateClusterMemberStateReturnsOnCall[len(fake.updateClusterMemberStateArgsForCall)]
	fake.updateClusterMemberStateArgsForCall = append(fake.updateClusterMemberStateArgsForCall, struct {
		arg1 string
		arg2 api.ClusterMemberStatePost
	}{arg1, arg2})
	stub := fake.UpdateClusterMemberStateStub
	fakeReturns := fake.updateClusterMemberStateReturns
	fake.recordInvocation("UpdateClusterMemberState", []interface{}{arg1, arg2})
	fake.updateClusterMemberStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateClusterMemberStateCallCount() int {
	fake.updateClusterMemberStateMutex.RLock()
	defer fake.updateClusterMemberStateMutex.RUnlock()
	return len(fake.updateClusterMemberStateArgsForCall)
}

func (fake *FakeContainerServer) UpdateClusterMemberStateCalls(stub func(string, api.ClusterMemberStatePost) (lxd.Operation, error)) {
	fake.updateClusterMemberStateMutex.Lock()
	defer fake.updateClusterMemberStateMutex.Unlock()
	fake.UpdateClusterMemberStateStub = stub
}

func (fake *FakeContainerServer) UpdateClusterMemberStateArgsForCall(i int) (string, api.ClusterMemberStatePost) {
	fake.updateClusterMemberStateMutex.RLock()
	defer fake.updateClusterMemberStateMutex.RUnlock()
	argsForCall := fake.updateClusterMemberStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) UpdateClusterMemberStateReturns(result1 lxd.Operation, result2 error) {
	fake.updateClusterMemberStateMutex.Lock()
	defer fake.updateClusterMemberStateMutex.Unlock()
	fake.UpdateClusterMemberStateStub = nil
	fake.updateClusterMemberStateReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateClusterMemberStateReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateClusterMemberStateMutex.Lock()
	defer fake.updateClusterMemberStateMutex.Unlock()
	fake.UpdateClusterMemberStateStub = nil
	if fake.updateClusterMemberStateReturnsOnCall == nil {
		fake.updateClusterMemberStateReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateClusterMemberStateReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainer(arg1 string, arg2 api.ContainerPut, arg3 string) (lxd.Operation, error) {
	fake.updateContainerMutex.Lock()
	ret, specificReturn := fake.updateContainerReturnsOnCall[len(fake.updateContainerArgsForCall)]
	fake.updateContainerArgsForCall = append(fake.updateContainerArgsForCall, struct {
		arg1 string
		arg2 api.ContainerPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateContainerStub
	fakeReturns := fake.updateContainerReturns
	fake.recordInvocation("UpdateContainer", []interface{}{arg1, arg2, arg3})
	fake.updateContainerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateContainerCallCount() int {
	fake.updateContainerMutex.RLock()
	defer fake.updateContainerMutex.RUnlock()
	return len(fake.updateContainerArgsForCall)
}

func (fake *FakeContainerServer) UpdateContainerCalls(stub func(string, api.ContainerPut, string) (lxd.Operation, error)) {
	fake.updateContainerMutex.Lock()
	defer fake.updateContainerMutex.Unlock()
	fake.UpdateContainerStub = stub
}

func (fake *FakeContainerServer) UpdateContainerArgsForCall(i int) (string, api.ContainerPut, string) {
	fake.updateContainerMutex.RLock()
	defer fake.updateContainerMutex.RUnlock()
	argsForCall := fake.updateContainerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateContainerReturns(result1 lxd.Operation, result2 error) {
	fake.updateContainerMutex.Lock()
	defer fake.updateContainerMutex.Unlock()
	fake.UpdateContainerStub = nil
	fake.updateContainerReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateContainerMutex.Lock()
	defer fake.updateContainerMutex.Unlock()
	fake.UpdateContainerStub = nil
	if fake.updateContainerReturnsOnCall == nil {
		fake.updateContainerReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateContainerReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerSnapshot(arg1 string, arg2 string, arg3 api.ContainerSnapshotPut, arg4 string) (lxd.Operation, error) {
	fake.updateContainerSnapshotMutex.Lock()
	ret, specificReturn := fake.updateContainerSnapshotReturnsOnCall[len(fake.updateContainerSnapshotArgsForCall)]
	fake.updateContainerSnapshotArgsForCall = append(fake.updateContainerSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.ContainerSnapshotPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateContainerSnapshotStub
	fakeReturns := fake.updateContainerSnapshotReturns
	fake.recordInvocation("UpdateContainerSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateContainerSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateContainerSnapshotCallCount() int {
	fake.updateContainerSnapshotMutex.RLock()
	defer fake.updateContainerSnapshotMutex.RUnlock()
	return len(fake.updateContainerSnapshotArgsForCall)
}

func (fake *FakeContainerServer) UpdateContainerSnapshotCalls(stub func(string, string, api.ContainerSnapshotPut, string) (lxd.Operation, error)) {
	fake.updateContainerSnapshotMutex.Lock()
	defer fake.updateContainerSnapshotMutex.Unlock()
	fake.UpdateContainerSnapshotStub = stub
}

func (fake *FakeContainerServer) UpdateContainerSnapshotArgsForCall(i int) (string, string, api.ContainerSnapshotPut, string) {
	fake.updateContainerSnapshotMutex.RLock()
	defer fake.updateContainerSnapshotMutex.RUnlock()
	argsForCall := fake.updateContainerSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateContainerSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.updateContainerSnapshotMutex.Lock()
	defer fake.updateContainerSnapshotMutex.Unlock()
	fake.UpdateContainerSnapshotStub = nil
	fake.updateContainerSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateContainerSnapshotMutex.Lock()
	defer fake.updateContainerSnapshotMutex.Unlock()
	fake.UpdateContainerSnapshotStub = nil
	if fake.updateContainerSnapshotReturnsOnCall == nil {
		fake.updateContainerSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateContainerSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerState(arg1 string, arg2 api.ContainerStatePut, arg3 string) (lxd.Operation, error) {
	fake.updateContainerStateMutex.Lock()
	ret, specificReturn := fake.updateContainerStateReturnsOnCall[len(fake.updateContainerStateArgsForCall)]
	fake.updateContainerStateArgsForCall = append(fake.updateContainerStateArgsForCall, struct {
		arg1 string
		arg2 api.ContainerStatePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateContainerStateStub
	fakeReturns := fake.updateContainerStateReturns
	fake.recordInvocation("UpdateContainerState", []interface{}{arg1, arg2, arg3})
	fake.updateContainerStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateContainerStateCallCount() int {
	fake.updateContainerStateMutex.RLock()
	defer fake.updateContainerStateMutex.RUnlock()
	return len(fake.updateContainerStateArgsForCall)
}

func (fake *FakeContainerServer) UpdateContainerStateCalls(stub func(string, api.ContainerStatePut, string) (lxd.Operation, error)) {
	fake.updateContainerStateMutex.Lock()
	defer fake.updateContainerStateMutex.Unlock()
	fake.UpdateContainerStateStub = stub
}

func (fake *FakeContainerServer) UpdateContainerStateArgsForCall(i int) (string, api.ContainerStatePut, string) {
	fake.updateContainerStateMutex.RLock()
	defer fake.updateContainerStateMutex.RUnlock()
	argsForCall := fake.updateContainerStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateContainerStateReturns(result1 lxd.Operation, result2 error) {
	fake.updateContainerStateMutex.Lock()
	defer fake.updateContainerStateMutex.Unlock()
	fake.UpdateContainerStateStub = nil
	fake.updateContainerStateReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerStateReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateContainerStateMutex.Lock()
	defer fake.updateContainerStateMutex.Unlock()
	fake.UpdateContainerStateStub = nil
	if fake.updateContainerStateReturnsOnCall == nil {
		fake.updateContainerStateReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateContainerStateReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateContainerTemplateFile(arg1 string, arg2 string, arg3 io.ReadSeeker) error {
	fake.updateContainerTemplateFileMutex.Lock()
	ret, specificReturn := fake.updateContainerTemplateFileReturnsOnCall[len(fake.updateContainerTemplateFileArgsForCall)]
	fake.updateContainerTemplateFileArgsForCall = append(fake.updateContainerTemplateFileArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.ReadSeeker
	}{arg1, arg2, arg3})
	stub := fake.UpdateContainerTemplateFileStub
	fakeReturns := fake.updateContainerTemplateFileReturns
	fake.recordInvocation("UpdateContainerTemplateFile", []interface{}{arg1, arg2, arg3})
	fake.updateContainerTemplateFileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateContainerTemplateFileCallCount() int {
	fake.updateContainerTemplateFileMutex.RLock()
	defer fake.updateContainerTemplateFileMutex.RUnlock()
	return len(fake.updateContainerTemplateFileArgsForCall)
}

func (fake *FakeContainerServer) UpdateContainerTemplateFileCalls(stub func(string, string, io.ReadSeeker) error) {
	fake.updateContainerTemplateFileMutex.Lock()
	defer fake.updateContainerTemplateFileMutex.Unlock()
	fake.UpdateContainerTemplateFileStub = stub
}

func (fake *FakeContainerServer) UpdateContainerTemplateFileArgsForCall(i int) (string, string, io.ReadSeeker) {
	fake.updateContainerTemplateFileMutex.RLock()
	defer fake.updateContainerTemplateFileMutex.RUnlock()
	argsForCall := fake.updateContainerTemplateFileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateContainerTemplateFileReturns(result1 error) {
	fake.updateContainerTemplateFileMutex.Lock()
	defer fake.updateContainerTemplateFileMutex.Unlock()
	fake.UpdateContainerTemplateFileStub = nil
	fake.updateContainerTemplateFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateContainerTemplateFileReturnsOnCall(i int, result1 error) {
	fake.updateContainerTemplateFileMutex.Lock()
	defer fake.updateContainerTemplateFileMutex.Unlock()
	fake.UpdateContainerTemplateFileStub = nil
	if fake.updateContainerTemplateFileReturnsOnCall == nil {
		fake.updateContainerTemplateFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateContainerTemplateFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateImage(arg1 string, arg2 api.ImagePut, arg3 string) error {
	fake.updateImageMutex.Lock()
	ret, specificReturn := fake.updateImageReturnsOnCall[len(fake.updateImageArgsForCall)]
	fake.updateImageArgsForCall = append(fake.updateImageArgsForCall, struct {
		arg1 string
		arg2 api.ImagePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateImageStub
	fakeReturns := fake.updateImageReturns
	fake.recordInvocation("UpdateImage", []interface{}{arg1, arg2, arg3})
	fake.updateImageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateImageCallCount() int {
	fake.updateImageMutex.RLock()
	defer fake.updateImageMutex.RUnlock()
	return len(fake.updateImageArgsForCall)
}

func (fake *FakeContainerServer) UpdateImageCalls(stub func(string, api.ImagePut, string) error) {
	fake.updateImageMutex.Lock()
	defer fake.updateImageMutex.Unlock()
	fake.UpdateImageStub = stub
}

func (fake *FakeContainerServer) UpdateImageArgsForCall(i int) (string, api.ImagePut, string) {
	fake.updateImageMutex.RLock()
	defer fake.updateImageMutex.RUnlock()
	argsForCall := fake.updateImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateImageReturns(result1 error) {
	fake.updateImageMutex.Lock()
	defer fake.updateImageMutex.Unlock()
	fake.UpdateImageStub = nil
	fake.updateImageReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateImageReturnsOnCall(i int, result1 error) {
	fake.updateImageMutex.Lock()
	defer fake.updateImageMutex.Unlock()
	fake.UpdateImageStub = nil
	if fake.updateImageReturnsOnCall == nil {
		fake.updateImageReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateImageReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateImageAlias(arg1 string, arg2 api.ImageAliasesEntryPut, arg3 string) error {
	fake.updateImageAliasMutex.Lock()
	ret, specificReturn := fake.updateImageAliasReturnsOnCall[len(fake.updateImageAliasArgsForCall)]
	fake.updateImageAliasArgsForCall = append(fake.updateImageAliasArgsForCall, struct {
		arg1 string
		arg2 api.ImageAliasesEntryPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateImageAliasStub
	fakeReturns := fake.updateImageAliasReturns
	fake.recordInvocation("UpdateImageAlias", []interface{}{arg1, arg2, arg3})
	fake.updateImageAliasMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateImageAliasCallCount() int {
	fake.updateImageAliasMutex.RLock()
	defer fake.updateImageAliasMutex.RUnlock()
	return len(fake.updateImageAliasArgsForCall)
}

func (fake *FakeContainerServer) UpdateImageAliasCalls(stub func(string, api.ImageAliasesEntryPut, string) error) {
	fake.updateImageAliasMutex.Lock()
	defer fake.updateImageAliasMutex.Unlock()
	fake.UpdateImageAliasStub = stub
}

func (fake *FakeContainerServer) UpdateImageAliasArgsForCall(i int) (string, api.ImageAliasesEntryPut, string) {
	fake.updateImageAliasMutex.RLock()
	defer fake.updateImageAliasMutex.RUnlock()
	argsForCall := fake.updateImageAliasArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateImageAliasReturns(result1 error) {
	fake.updateImageAliasMutex.Lock()
	defer fake.updateImageAliasMutex.Unlock()
	fake.UpdateImageAliasStub = nil
	fake.updateImageAliasReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateImageAliasReturnsOnCall(i int, result1 error) {
	fake.updateImageAliasMutex.Lock()
	defer fake.updateImageAliasMutex.Unlock()
	fake.UpdateImageAliasStub = nil
	if fake.updateImageAliasReturnsOnCall == nil {
		fake.updateImageAliasReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateImageAliasReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateInstance(arg1 string, arg2 api.InstancePut, arg3 string) (lxd.Operation, error) {
	fake.updateInstanceMutex.Lock()
	ret, specificReturn := fake.updateInstanceReturnsOnCall[len(fake.updateInstanceArgsForCall)]
	fake.updateInstanceArgsForCall = append(fake.updateInstanceArgsForCall, struct {
		arg1 string
		arg2 api.InstancePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateInstanceStub
	fakeReturns := fake.updateInstanceReturns
	fake.recordInvocation("UpdateInstance", []interface{}{arg1, arg2, arg3})
	fake.updateInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateInstanceCallCount() int {
	fake.updateInstanceMutex.RLock()
	defer fake.updateInstanceMutex.RUnlock()
	return len(fake.updateInstanceArgsForCall)
}

func (fake *FakeContainerServer) UpdateInstanceCalls(stub func(string, api.InstancePut, string) (lxd.Operation, error)) {
	fake.updateInstanceMutex.Lock()
	defer fake.updateInstanceMutex.Unlock()
	fake.UpdateInstanceStub = stub
}

func (fake *FakeContainerServer) UpdateInstanceArgsForCall(i int) (string, api.InstancePut, string) {
	fake.updateInstanceMutex.RLock()
	defer fake.updateInstanceMutex.RUnlock()
	argsForCall := fake.updateInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateInstanceReturns(result1 lxd.Operation, result2 error) {
	fake.updateInstanceMutex.Lock()
	defer fake.updateInstanceMutex.Unlock()
	fake.UpdateInstanceStub = nil
	fake.updateInstanceReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstanceReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateInstanceMutex.Lock()
	defer fake.updateInstanceMutex.Unlock()
	fake.UpdateInstanceStub = nil
	if fake.updateInstanceReturnsOnCall == nil {
		fake.updateInstanceReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateInstanceReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstanceMetadata(arg1 string, arg2 api.ImageMetadata, arg3 string) error {
	fake.updateInstanceMetadataMutex.Lock()
	ret, specificReturn := fake.updateInstanceMetadataReturnsOnCall[len(fake.updateInstanceMetadataArgsForCall)]
	fake.updateInstanceMetadataArgsForCall = append(fake.updateInstanceMetadataArgsForCall, struct {
		arg1 string
		arg2 api.ImageMetadata
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateInstanceMetadataStub
	fakeReturns := fake.updateInstanceMetadataReturns
	fake.recordInvocation("UpdateInstanceMetadata", []interface{}{arg1, arg2, arg3})
	fake.updateInstanceMetadataMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateInstanceMetadataCallCount() int {
	fake.updateInstanceMetadataMutex.RLock()
	defer fake.updateInstanceMetadataMutex.RUnlock()
	return len(fake.updateInstanceMetadataArgsForCall)
}

func (fake *FakeContainerServer) UpdateInstanceMetadataCalls(stub func(string, api.ImageMetadata, string) error) {
	fake.updateInstanceMetadataMutex.Lock()
	defer fake.updateInstanceMetadataMutex.Unlock()
	fake.UpdateInstanceMetadataStub = stub
}

func (fake *FakeContainerServer) UpdateInstanceMetadataArgsForCall(i int) (string, api.ImageMetadata, string) {
	fake.updateInstanceMetadataMutex.RLock()
	defer fake.updateInstanceMetadataMutex.RUnlock()
	argsForCall := fake.updateInstanceMetadataArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateInstanceMetadataReturns(result1 error) {
	fake.updateInstanceMetadataMutex.Lock()
	defer fake.updateInstanceMetadataMutex.Unlock()
	fake.UpdateInstanceMetadataStub = nil
	fake.updateInstanceMetadataReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateInstanceMetadataReturnsOnCall(i int, result1 error) {
	fake.updateInstanceMetadataMutex.Lock()
	defer fake.updateInstanceMetadataMutex.Unlock()
	fake.UpdateInstanceMetadataStub = nil
	if fake.updateInstanceMetadataReturnsOnCall == nil {
		fake.updateInstanceMetadataReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateInstanceMetadataReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateInstanceSnapshot(arg1 string, arg2 string, arg3 api.InstanceSnapshotPut, arg4 string) (lxd.Operation, error) {
	fake.updateInstanceSnapshotMutex.Lock()
	ret, specificReturn := fake.updateInstanceSnapshotReturnsOnCall[len(fake.updateInstanceSnapshotArgsForCall)]
	fake.updateInstanceSnapshotArgsForCall = append(fake.updateInstanceSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.InstanceSnapshotPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateInstanceSnapshotStub
	fakeReturns := fake.updateInstanceSnapshotReturns
	fake.recordInvocation("UpdateInstanceSnapshot", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateInstanceSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateInstanceSnapshotCallCount() int {
	fake.updateInstanceSnapshotMutex.RLock()
	defer fake.updateInstanceSnapshotMutex.RUnlock()
	return len(fake.updateInstanceSnapshotArgsForCall)
}

func (fake *FakeContainerServer) UpdateInstanceSnapshotCalls(stub func(string, string, api.InstanceSnapshotPut, string) (lxd.Operation, error)) {
	fake.updateInstanceSnapshotMutex.Lock()
	defer fake.updateInstanceSnapshotMutex.Unlock()
	fake.UpdateInstanceSnapshotStub = stub
}

func (fake *FakeContainerServer) UpdateInstanceSnapshotArgsForCall(i int) (string, string, api.InstanceSnapshotPut, string) {
	fake.updateInstanceSnapshotMutex.RLock()
	defer fake.updateInstanceSnapshotMutex.RUnlock()
	argsForCall := fake.updateInstanceSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateInstanceSnapshotReturns(result1 lxd.Operation, result2 error) {
	fake.updateInstanceSnapshotMutex.Lock()
	defer fake.updateInstanceSnapshotMutex.Unlock()
	fake.UpdateInstanceSnapshotStub = nil
	fake.updateInstanceSnapshotReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstanceSnapshotReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateInstanceSnapshotMutex.Lock()
	defer fake.updateInstanceSnapshotMutex.Unlock()
	fake.UpdateInstanceSnapshotStub = nil
	if fake.updateInstanceSnapshotReturnsOnCall == nil {
		fake.updateInstanceSnapshotReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateInstanceSnapshotReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstanceState(arg1 string, arg2 api.InstanceStatePut, arg3 string) (lxd.Operation, error) {
	fake.updateInstanceStateMutex.Lock()
	ret, specificReturn := fake.updateInstanceStateReturnsOnCall[len(fake.updateInstanceStateArgsForCall)]
	fake.updateInstanceStateArgsForCall = append(fake.updateInstanceStateArgsForCall, struct {
		arg1 string
		arg2 api.InstanceStatePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateInstanceStateStub
	fakeReturns := fake.updateInstanceStateReturns
	fake.recordInvocation("UpdateInstanceState", []interface{}{arg1, arg2, arg3})
	fake.updateInstanceStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateInstanceStateCallCount() int {
	fake.updateInstanceStateMutex.RLock()
	defer fake.updateInstanceStateMutex.RUnlock()
	return len(fake.updateInstanceStateArgsForCall)
}

func (fake *FakeContainerServer) UpdateInstanceStateCalls(stub func(string, api.InstanceStatePut, string) (lxd.Operation, error)) {
	fake.updateInstanceStateMutex.Lock()
	defer fake.updateInstanceStateMutex.Unlock()
	fake.UpdateInstanceStateStub = stub
}

func (fake *FakeContainerServer) UpdateInstanceStateArgsForCall(i int) (string, api.InstanceStatePut, string) {
	fake.updateInstanceStateMutex.RLock()
	defer fake.updateInstanceStateMutex.RUnlock()
	argsForCall := fake.updateInstanceStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateInstanceStateReturns(result1 lxd.Operation, result2 error) {
	fake.updateInstanceStateMutex.Lock()
	defer fake.updateInstanceStateMutex.Unlock()
	fake.UpdateInstanceStateStub = nil
	fake.updateInstanceStateReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstanceStateReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateInstanceStateMutex.Lock()
	defer fake.updateInstanceStateMutex.Unlock()
	fake.UpdateInstanceStateStub = nil
	if fake.updateInstanceStateReturnsOnCall == nil {
		fake.updateInstanceStateReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateInstanceStateReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstances(arg1 api.InstancesPut, arg2 string) (lxd.Operation, error) {
	fake.updateInstancesMutex.Lock()
	ret, specificReturn := fake.updateInstancesReturnsOnCall[len(fake.updateInstancesArgsForCall)]
	fake.updateInstancesArgsForCall = append(fake.updateInstancesArgsForCall, struct {
		arg1 api.InstancesPut
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateInstancesStub
	fakeReturns := fake.updateInstancesReturns
	fake.recordInvocation("UpdateInstances", []interface{}{arg1, arg2})
	fake.updateInstancesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerServer) UpdateInstancesCallCount() int {
	fake.updateInstancesMutex.RLock()
	defer fake.updateInstancesMutex.RUnlock()
	return len(fake.updateInstancesArgsForCall)
}

func (fake *FakeContainerServer) UpdateInstancesCalls(stub func(api.InstancesPut, string) (lxd.Operation, error)) {
	fake.updateInstancesMutex.Lock()
	defer fake.updateInstancesMutex.Unlock()
	fake.UpdateInstancesStub = stub
}

func (fake *FakeContainerServer) UpdateInstancesArgsForCall(i int) (api.InstancesPut, string) {
	fake.updateInstancesMutex.RLock()
	defer fake.updateInstancesMutex.RUnlock()
	argsForCall := fake.updateInstancesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) UpdateInstancesReturns(result1 lxd.Operation, result2 error) {
	fake.updateInstancesMutex.Lock()
	defer fake.updateInstancesMutex.Unlock()
	fake.UpdateInstancesStub = nil
	fake.updateInstancesReturns = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateInstancesReturnsOnCall(i int, result1 lxd.Operation, result2 error) {
	fake.updateInstancesMutex.Lock()
	defer fake.updateInstancesMutex.Unlock()
	fake.UpdateInstancesStub = nil
	if fake.updateInstancesReturnsOnCall == nil {
		fake.updateInstancesReturnsOnCall = make(map[int]struct {
			result1 lxd.Operation
			result2 error
		})
	}
	fake.updateInstancesReturnsOnCall[i] = struct {
		result1 lxd.Operation
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerServer) UpdateNetwork(arg1 string, arg2 api.NetworkPut, arg3 string) error {
	fake.updateNetworkMutex.Lock()
	ret, specificReturn := fake.updateNetworkReturnsOnCall[len(fake.updateNetworkArgsForCall)]
	fake.updateNetworkArgsForCall = append(fake.updateNetworkArgsForCall, struct {
		arg1 string
		arg2 api.NetworkPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateNetworkStub
	fakeReturns := fake.updateNetworkReturns
	fake.recordInvocation("UpdateNetwork", []interface{}{arg1, arg2, arg3})
	fake.updateNetworkMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkCallCount() int {
	fake.updateNetworkMutex.RLock()
	defer fake.updateNetworkMutex.RUnlock()
	return len(fake.updateNetworkArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkCalls(stub func(string, api.NetworkPut, string) error) {
	fake.updateNetworkMutex.Lock()
	defer fake.updateNetworkMutex.Unlock()
	fake.UpdateNetworkStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkArgsForCall(i int) (string, api.NetworkPut, string) {
	fake.updateNetworkMutex.RLock()
	defer fake.updateNetworkMutex.RUnlock()
	argsForCall := fake.updateNetworkArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateNetworkReturns(result1 error) {
	fake.updateNetworkMutex.Lock()
	defer fake.updateNetworkMutex.Unlock()
	fake.UpdateNetworkStub = nil
	fake.updateNetworkReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkReturnsOnCall(i int, result1 error) {
	fake.updateNetworkMutex.Lock()
	defer fake.updateNetworkMutex.Unlock()
	fake.UpdateNetworkStub = nil
	if fake.updateNetworkReturnsOnCall == nil {
		fake.updateNetworkReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkACL(arg1 string, arg2 api.NetworkACLPut, arg3 string) error {
	fake.updateNetworkACLMutex.Lock()
	ret, specificReturn := fake.updateNetworkACLReturnsOnCall[len(fake.updateNetworkACLArgsForCall)]
	fake.updateNetworkACLArgsForCall = append(fake.updateNetworkACLArgsForCall, struct {
		arg1 string
		arg2 api.NetworkACLPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateNetworkACLStub
	fakeReturns := fake.updateNetworkACLReturns
	fake.recordInvocation("UpdateNetworkACL", []interface{}{arg1, arg2, arg3})
	fake.updateNetworkACLMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkACLCallCount() int {
	fake.updateNetworkACLMutex.RLock()
	defer fake.updateNetworkACLMutex.RUnlock()
	return len(fake.updateNetworkACLArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkACLCalls(stub func(string, api.NetworkACLPut, string) error) {
	fake.updateNetworkACLMutex.Lock()
	defer fake.updateNetworkACLMutex.Unlock()
	fake.UpdateNetworkACLStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkACLArgsForCall(i int) (string, api.NetworkACLPut, string) {
	fake.updateNetworkACLMutex.RLock()
	defer fake.updateNetworkACLMutex.RUnlock()
	argsForCall := fake.updateNetworkACLArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateNetworkACLReturns(result1 error) {
	fake.updateNetworkACLMutex.Lock()
	defer fake.updateNetworkACLMutex.Unlock()
	fake.UpdateNetworkACLStub = nil
	fake.updateNetworkACLReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkACLReturnsOnCall(i int, result1 error) {
	fake.updateNetworkACLMutex.Lock()
	defer fake.updateNetworkACLMutex.Unlock()
	fake.UpdateNetworkACLStub = nil
	if fake.updateNetworkACLReturnsOnCall == nil {
		fake.updateNetworkACLReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkACLReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkForward(arg1 string, arg2 string, arg3 api.NetworkForwardPut, arg4 string) error {
	fake.updateNetworkForwardMutex.Lock()
	ret, specificReturn := fake.updateNetworkForwardReturnsOnCall[len(fake.updateNetworkForwardArgsForCall)]
	fake.updateNetworkForwardArgsForCall = append(fake.updateNetworkForwardArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.NetworkForwardPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateNetworkForwardStub
	fakeReturns := fake.updateNetworkForwardReturns
	fake.recordInvocation("UpdateNetworkForward", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateNetworkForwardMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkForwardCallCount() int {
	fake.updateNetworkForwardMutex.RLock()
	defer fake.updateNetworkForwardMutex.RUnlock()
	return len(fake.updateNetworkForwardArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkForwardCalls(stub func(string, string, api.NetworkForwardPut, string) error) {
	fake.updateNetworkForwardMutex.Lock()
	defer fake.updateNetworkForwardMutex.Unlock()
	fake.UpdateNetworkForwardStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkForwardArgsForCall(i int) (string, string, api.NetworkForwardPut, string) {
	fake.updateNetworkForwardMutex.RLock()
	defer fake.updateNetworkForwardMutex.RUnlock()
	argsForCall := fake.updateNetworkForwardArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateNetworkForwardReturns(result1 error) {
	fake.updateNetworkForwardMutex.Lock()
	defer fake.updateNetworkForwardMutex.Unlock()
	fake.UpdateNetworkForwardStub = nil
	fake.updateNetworkForwardReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkForwardReturnsOnCall(i int, result1 error) {
	fake.updateNetworkForwardMutex.Lock()
	defer fake.updateNetworkForwardMutex.Unlock()
	fake.UpdateNetworkForwardStub = nil
	if fake.updateNetworkForwardReturnsOnCall == nil {
		fake.updateNetworkForwardReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkForwardReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancer(arg1 string, arg2 string, arg3 api.NetworkLoadBalancerPut, arg4 string) error {
	fake.updateNetworkLoadBalancerMutex.Lock()
	ret, specificReturn := fake.updateNetworkLoadBalancerReturnsOnCall[len(fake.updateNetworkLoadBalancerArgsForCall)]
	fake.updateNetworkLoadBalancerArgsForCall = append(fake.updateNetworkLoadBalancerArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.NetworkLoadBalancerPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateNetworkLoadBalancerStub
	fakeReturns := fake.updateNetworkLoadBalancerReturns
	fake.recordInvocation("UpdateNetworkLoadBalancer", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateNetworkLoadBalancerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancerCallCount() int {
	fake.updateNetworkLoadBalancerMutex.RLock()
	defer fake.updateNetworkLoadBalancerMutex.RUnlock()
	return len(fake.updateNetworkLoadBalancerArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancerCalls(stub func(string, string, api.NetworkLoadBalancerPut, string) error) {
	fake.updateNetworkLoadBalancerMutex.Lock()
	defer fake.updateNetworkLoadBalancerMutex.Unlock()
	fake.UpdateNetworkLoadBalancerStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancerArgsForCall(i int) (string, string, api.NetworkLoadBalancerPut, string) {
	fake.updateNetworkLoadBalancerMutex.RLock()
	defer fake.updateNetworkLoadBalancerMutex.RUnlock()
	argsForCall := fake.updateNetworkLoadBalancerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancerReturns(result1 error) {
	fake.updateNetworkLoadBalancerMutex.Lock()
	defer fake.updateNetworkLoadBalancerMutex.Unlock()
	fake.UpdateNetworkLoadBalancerStub = nil
	fake.updateNetworkLoadBalancerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkLoadBalancerReturnsOnCall(i int, result1 error) {
	fake.updateNetworkLoadBalancerMutex.Lock()
	defer fake.updateNetworkLoadBalancerMutex.Unlock()
	fake.UpdateNetworkLoadBalancerStub = nil
	if fake.updateNetworkLoadBalancerReturnsOnCall == nil {
		fake.updateNetworkLoadBalancerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkLoadBalancerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkPeer(arg1 string, arg2 string, arg3 api.NetworkPeerPut, arg4 string) error {
	fake.updateNetworkPeerMutex.Lock()
	ret, specificReturn := fake.updateNetworkPeerReturnsOnCall[len(fake.updateNetworkPeerArgsForCall)]
	fake.updateNetworkPeerArgsForCall = append(fake.updateNetworkPeerArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.NetworkPeerPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateNetworkPeerStub
	fakeReturns := fake.updateNetworkPeerReturns
	fake.recordInvocation("UpdateNetworkPeer", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateNetworkPeerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkPeerCallCount() int {
	fake.updateNetworkPeerMutex.RLock()
	defer fake.updateNetworkPeerMutex.RUnlock()
	return len(fake.updateNetworkPeerArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkPeerCalls(stub func(string, string, api.NetworkPeerPut, string) error) {
	fake.updateNetworkPeerMutex.Lock()
	defer fake.updateNetworkPeerMutex.Unlock()
	fake.UpdateNetworkPeerStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkPeerArgsForCall(i int) (string, string, api.NetworkPeerPut, string) {
	fake.updateNetworkPeerMutex.RLock()
	defer fake.updateNetworkPeerMutex.RUnlock()
	argsForCall := fake.updateNetworkPeerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateNetworkPeerReturns(result1 error) {
	fake.updateNetworkPeerMutex.Lock()
	defer fake.updateNetworkPeerMutex.Unlock()
	fake.UpdateNetworkPeerStub = nil
	fake.updateNetworkPeerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkPeerReturnsOnCall(i int, result1 error) {
	fake.updateNetworkPeerMutex.Lock()
	defer fake.updateNetworkPeerMutex.Unlock()
	fake.UpdateNetworkPeerStub = nil
	if fake.updateNetworkPeerReturnsOnCall == nil {
		fake.updateNetworkPeerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkPeerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkZone(arg1 string, arg2 api.NetworkZonePut, arg3 string) error {
	fake.updateNetworkZoneMutex.Lock()
	ret, specificReturn := fake.updateNetworkZoneReturnsOnCall[len(fake.updateNetworkZoneArgsForCall)]
	fake.updateNetworkZoneArgsForCall = append(fake.updateNetworkZoneArgsForCall, struct {
		arg1 string
		arg2 api.NetworkZonePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateNetworkZoneStub
	fakeReturns := fake.updateNetworkZoneReturns
	fake.recordInvocation("UpdateNetworkZone", []interface{}{arg1, arg2, arg3})
	fake.updateNetworkZoneMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkZoneCallCount() int {
	fake.updateNetworkZoneMutex.RLock()
	defer fake.updateNetworkZoneMutex.RUnlock()
	return len(fake.updateNetworkZoneArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkZoneCalls(stub func(string, api.NetworkZonePut, string) error) {
	fake.updateNetworkZoneMutex.Lock()
	defer fake.updateNetworkZoneMutex.Unlock()
	fake.UpdateNetworkZoneStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkZoneArgsForCall(i int) (string, api.NetworkZonePut, string) {
	fake.updateNetworkZoneMutex.RLock()
	defer fake.updateNetworkZoneMutex.RUnlock()
	argsForCall := fake.updateNetworkZoneArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateNetworkZoneReturns(result1 error) {
	fake.updateNetworkZoneMutex.Lock()
	defer fake.updateNetworkZoneMutex.Unlock()
	fake.UpdateNetworkZoneStub = nil
	fake.updateNetworkZoneReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkZoneReturnsOnCall(i int, result1 error) {
	fake.updateNetworkZoneMutex.Lock()
	defer fake.updateNetworkZoneMutex.Unlock()
	fake.UpdateNetworkZoneStub = nil
	if fake.updateNetworkZoneReturnsOnCall == nil {
		fake.updateNetworkZoneReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkZoneReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecord(arg1 string, arg2 string, arg3 api.NetworkZoneRecordPut, arg4 string) error {
	fake.updateNetworkZoneRecordMutex.Lock()
	ret, specificReturn := fake.updateNetworkZoneRecordReturnsOnCall[len(fake.updateNetworkZoneRecordArgsForCall)]
	fake.updateNetworkZoneRecordArgsForCall = append(fake.updateNetworkZoneRecordArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 api.NetworkZoneRecordPut
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateNetworkZoneRecordStub
	fakeReturns := fake.updateNetworkZoneRecordReturns
	fake.recordInvocation("UpdateNetworkZoneRecord", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateNetworkZoneRecordMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecordCallCount() int {
	fake.updateNetworkZoneRecordMutex.RLock()
	defer fake.updateNetworkZoneRecordMutex.RUnlock()
	return len(fake.updateNetworkZoneRecordArgsForCall)
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecordCalls(stub func(string, string, api.NetworkZoneRecordPut, string) error) {
	fake.updateNetworkZoneRecordMutex.Lock()
	defer fake.updateNetworkZoneRecordMutex.Unlock()
	fake.UpdateNetworkZoneRecordStub = stub
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecordArgsForCall(i int) (string, string, api.NetworkZoneRecordPut, string) {
	fake.updateNetworkZoneRecordMutex.RLock()
	defer fake.updateNetworkZoneRecordMutex.RUnlock()
	argsForCall := fake.updateNetworkZoneRecordArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecordReturns(result1 error) {
	fake.updateNetworkZoneRecordMutex.Lock()
	defer fake.updateNetworkZoneRecordMutex.Unlock()
	fake.UpdateNetworkZoneRecordStub = nil
	fake.updateNetworkZoneRecordReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateNetworkZoneRecordReturnsOnCall(i int, result1 error) {
	fake.updateNetworkZoneRecordMutex.Lock()
	defer fake.updateNetworkZoneRecordMutex.Unlock()
	fake.UpdateNetworkZoneRecordStub = nil
	if fake.updateNetworkZoneRecordReturnsOnCall == nil {
		fake.updateNetworkZoneRecordReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNetworkZoneRecordReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateProfile(arg1 string, arg2 api.ProfilePut, arg3 string) error {
	fake.updateProfileMutex.Lock()
	ret, specificReturn := fake.updateProfileReturnsOnCall[len(fake.updateProfileArgsForCall)]
	fake.updateProfileArgsForCall = append(fake.updateProfileArgsForCall, struct {
		arg1 string
		arg2 api.ProfilePut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateProfileStub
	fakeReturns := fake.updateProfileReturns
	fake.recordInvocation("UpdateProfile", []interface{}{arg1, arg2, arg3})
	fake.updateProfileMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateProfileCallCount() int {
	fake.updateProfileMutex.RLock()
	defer fake.updateProfileMutex.RUnlock()
	return len(fake.updateProfileArgsForCall)
}

func (fake *FakeContainerServer) UpdateProfileCalls(stub func(string, api.ProfilePut, string) error) {
	fake.updateProfileMutex.Lock()
	defer fake.updateProfileMutex.Unlock()
	fake.UpdateProfileStub = stub
}

func (fake *FakeContainerServer) UpdateProfileArgsForCall(i int) (string, api.ProfilePut, string) {
	fake.updateProfileMutex.RLock()
	defer fake.updateProfileMutex.RUnlock()
	argsForCall := fake.updateProfileArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateProfileReturns(result1 error) {
	fake.updateProfileMutex.Lock()
	defer fake.updateProfileMutex.Unlock()
	fake.UpdateProfileStub = nil
	fake.updateProfileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateProfileReturnsOnCall(i int, result1 error) {
	fake.updateProfileMutex.Lock()
	defer fake.updateProfileMutex.Unlock()
	fake.UpdateProfileStub = nil
	if fake.updateProfileReturnsOnCall == nil {
		fake.updateProfileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateProfileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateProject(arg1 string, arg2 api.ProjectPut, arg3 string) error {
	fake.updateProjectMutex.Lock()
	ret, specificReturn := fake.updateProjectReturnsOnCall[len(fake.updateProjectArgsForCall)]
	fake.updateProjectArgsForCall = append(fake.updateProjectArgsForCall, struct {
		arg1 string
		arg2 api.ProjectPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateProjectStub
	fakeReturns := fake.updateProjectReturns
	fake.recordInvocation("UpdateProject", []interface{}{arg1, arg2, arg3})
	fake.updateProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateProjectCallCount() int {
	fake.updateProjectMutex.RLock()
	defer fake.updateProjectMutex.RUnlock()
	return len(fake.updateProjectArgsForCall)
}

func (fake *FakeContainerServer) UpdateProjectCalls(stub func(string, api.ProjectPut, string) error) {
	fake.updateProjectMutex.Lock()
	defer fake.updateProjectMutex.Unlock()
	fake.UpdateProjectStub = stub
}

func (fake *FakeContainerServer) UpdateProjectArgsForCall(i int) (string, api.ProjectPut, string) {
	fake.updateProjectMutex.RLock()
	defer fake.updateProjectMutex.RUnlock()
	argsForCall := fake.updateProjectArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateProjectReturns(result1 error) {
	fake.updateProjectMutex.Lock()
	defer fake.updateProjectMutex.Unlock()
	fake.UpdateProjectStub = nil
	fake.updateProjectReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateProjectReturnsOnCall(i int, result1 error) {
	fake.updateProjectMutex.Lock()
	defer fake.updateProjectMutex.Unlock()
	fake.UpdateProjectStub = nil
	if fake.updateProjectReturnsOnCall == nil {
		fake.updateProjectReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateProjectReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateServer(arg1 api.ServerPut, arg2 string) error {
	fake.updateServerMutex.Lock()
	ret, specificReturn := fake.updateServerReturnsOnCall[len(fake.updateServerArgsForCall)]
	fake.updateServerArgsForCall = append(fake.updateServerArgsForCall, struct {
		arg1 api.ServerPut
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateServerStub
	fakeReturns := fake.updateServerReturns
	fake.recordInvocation("UpdateServer", []interface{}{arg1, arg2})
	fake.updateServerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateServerCallCount() int {
	fake.updateServerMutex.RLock()
	defer fake.updateServerMutex.RUnlock()
	return len(fake.updateServerArgsForCall)
}

func (fake *FakeContainerServer) UpdateServerCalls(stub func(api.ServerPut, string) error) {
	fake.updateServerMutex.Lock()
	defer fake.updateServerMutex.Unlock()
	fake.UpdateServerStub = stub
}

func (fake *FakeContainerServer) UpdateServerArgsForCall(i int) (api.ServerPut, string) {
	fake.updateServerMutex.RLock()
	defer fake.updateServerMutex.RUnlock()
	argsForCall := fake.updateServerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerServer) UpdateServerReturns(result1 error) {
	fake.updateServerMutex.Lock()
	defer fake.updateServerMutex.Unlock()
	fake.UpdateServerStub = nil
	fake.updateServerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateServerReturnsOnCall(i int, result1 error) {
	fake.updateServerMutex.Lock()
	defer fake.updateServerMutex.Unlock()
	fake.UpdateServerStub = nil
	if fake.updateServerReturnsOnCall == nil {
		fake.updateServerReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateServerReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePool(arg1 string, arg2 api.StoragePoolPut, arg3 string) error {
	fake.updateStoragePoolMutex.Lock()
	ret, specificReturn := fake.updateStoragePoolReturnsOnCall[len(fake.updateStoragePoolArgsForCall)]
	fake.updateStoragePoolArgsForCall = append(fake.updateStoragePoolArgsForCall, struct {
		arg1 string
		arg2 api.StoragePoolPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateStoragePoolStub
	fakeReturns := fake.updateStoragePoolReturns
	fake.recordInvocation("UpdateStoragePool", []interface{}{arg1, arg2, arg3})
	fake.updateStoragePoolMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateStoragePoolCallCount() int {
	fake.updateStoragePoolMutex.RLock()
	defer fake.updateStoragePoolMutex.RUnlock()
	return len(fake.updateStoragePoolArgsForCall)
}

func (fake *FakeContainerServer) UpdateStoragePoolCalls(stub func(string, api.StoragePoolPut, string) error) {
	fake.updateStoragePoolMutex.Lock()
	defer fake.updateStoragePoolMutex.Unlock()
	fake.UpdateStoragePoolStub = stub
}

func (fake *FakeContainerServer) UpdateStoragePoolArgsForCall(i int) (string, api.StoragePoolPut, string) {
	fake.updateStoragePoolMutex.RLock()
	defer fake.updateStoragePoolMutex.RUnlock()
	argsForCall := fake.updateStoragePoolArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateStoragePoolReturns(result1 error) {
	fake.updateStoragePoolMutex.Lock()
	defer fake.updateStoragePoolMutex.Unlock()
	fake.UpdateStoragePoolStub = nil
	fake.updateStoragePoolReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePoolReturnsOnCall(i int, result1 error) {
	fake.updateStoragePoolMutex.Lock()
	defer fake.updateStoragePoolMutex.Unlock()
	fake.UpdateStoragePoolStub = nil
	if fake.updateStoragePoolReturnsOnCall == nil {
		fake.updateStoragePoolReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateStoragePoolReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePoolVolume(arg1 string, arg2 string, arg3 string, arg4 api.StorageVolumePut, arg5 string) error {
	fake.updateStoragePoolVolumeMutex.Lock()
	ret, specificReturn := fake.updateStoragePoolVolumeReturnsOnCall[len(fake.updateStoragePoolVolumeArgsForCall)]
	fake.updateStoragePoolVolumeArgsForCall = append(fake.updateStoragePoolVolumeArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 api.StorageVolumePut
		arg5 string
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.UpdateStoragePoolVolumeStub
	fakeReturns := fake.updateStoragePoolVolumeReturns
	fake.recordInvocation("UpdateStoragePoolVolume", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.updateStoragePoolVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeCallCount() int {
	fake.updateStoragePoolVolumeMutex.RLock()
	defer fake.updateStoragePoolVolumeMutex.RUnlock()
	return len(fake.updateStoragePoolVolumeArgsForCall)
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeCalls(stub func(string, string, string, api.StorageVolumePut, string) error) {
	fake.updateStoragePoolVolumeMutex.Lock()
	defer fake.updateStoragePoolVolumeMutex.Unlock()
	fake.UpdateStoragePoolVolumeStub = stub
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeArgsForCall(i int) (string, string, string, api.StorageVolumePut, string) {
	fake.updateStoragePoolVolumeMutex.RLock()
	defer fake.updateStoragePoolVolumeMutex.RUnlock()
	argsForCall := fake.updateStoragePoolVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeReturns(result1 error) {
	fake.updateStoragePoolVolumeMutex.Lock()
	defer fake.updateStoragePoolVolumeMutex.Unlock()
	fake.UpdateStoragePoolVolumeStub = nil
	fake.updateStoragePoolVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeReturnsOnCall(i int, result1 error) {
	fake.updateStoragePoolVolumeMutex.Lock()
	defer fake.updateStoragePoolVolumeMutex.Unlock()
	fake.UpdateStoragePoolVolumeStub = nil
	if fake.updateStoragePoolVolumeReturnsOnCall == nil {
		fake.updateStoragePoolVolumeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateStoragePoolVolumeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshot(arg1 string, arg2 string, arg3 string, arg4 string, arg5 api.StorageVolumeSnapshotPut, arg6 string) error {
	fake.updateStoragePoolVolumeSnapshotMutex.Lock()
	ret, specificReturn := fake.updateStoragePoolVolumeSnapshotReturnsOnCall[len(fake.updateStoragePoolVolumeSnapshotArgsForCall)]
	fake.updateStoragePoolVolumeSnapshotArgsForCall = append(fake.updateStoragePoolVolumeSnapshotArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 api.StorageVolumeSnapshotPut
		arg6 string
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	stub := fake.UpdateStoragePoolVolumeSnapshotStub
	fakeReturns := fake.updateStoragePoolVolumeSnapshotReturns
	fake.recordInvocation("UpdateStoragePoolVolumeSnapshot", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.updateStoragePoolVolumeSnapshotMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshotCallCount() int {
	fake.updateStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.RUnlock()
	return len(fake.updateStoragePoolVolumeSnapshotArgsForCall)
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshotCalls(stub func(string, string, string, string, api.StorageVolumeSnapshotPut, string) error) {
	fake.updateStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.Unlock()
	fake.UpdateStoragePoolVolumeSnapshotStub = stub
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshotArgsForCall(i int) (string, string, string, string, api.StorageVolumeSnapshotPut, string) {
	fake.updateStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.RUnlock()
	argsForCall := fake.updateStoragePoolVolumeSnapshotArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshotReturns(result1 error) {
	fake.updateStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.Unlock()
	fake.UpdateStoragePoolVolumeSnapshotStub = nil
	fake.updateStoragePoolVolumeSnapshotReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateStoragePoolVolumeSnapshotReturnsOnCall(i int, result1 error) {
	fake.updateStoragePoolVolumeSnapshotMutex.Lock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.Unlock()
	fake.UpdateStoragePoolVolumeSnapshotStub = nil
	if fake.updateStoragePoolVolumeSnapshotReturnsOnCall == nil {
		fake.updateStoragePoolVolumeSnapshotReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateStoragePoolVolumeSnapshotReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateWarning(arg1 string, arg2 api.WarningPut, arg3 string) error {
	fake.updateWarningMutex.Lock()
	ret, specificReturn := fake.updateWarningReturnsOnCall[len(fake.updateWarningArgsForCall)]
	fake.updateWarningArgsForCall = append(fake.updateWarningArgsForCall, struct {
		arg1 string
		arg2 api.WarningPut
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateWarningStub
	fakeReturns := fake.updateWarningReturns
	fake.recordInvocation("UpdateWarning", []interface{}{arg1, arg2, arg3})
	fake.updateWarningMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UpdateWarningCallCount() int {
	fake.updateWarningMutex.RLock()
	defer fake.updateWarningMutex.RUnlock()
	return len(fake.updateWarningArgsForCall)
}

func (fake *FakeContainerServer) UpdateWarningCalls(stub func(string, api.WarningPut, string) error) {
	fake.updateWarningMutex.Lock()
	defer fake.updateWarningMutex.Unlock()
	fake.UpdateWarningStub = stub
}

func (fake *FakeContainerServer) UpdateWarningArgsForCall(i int) (string, api.WarningPut, string) {
	fake.updateWarningMutex.RLock()
	defer fake.updateWarningMutex.RUnlock()
	argsForCall := fake.updateWarningArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeContainerServer) UpdateWarningReturns(result1 error) {
	fake.updateWarningMutex.Lock()
	defer fake.updateWarningMutex.Unlock()
	fake.UpdateWarningStub = nil
	fake.updateWarningReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UpdateWarningReturnsOnCall(i int, result1 error) {
	fake.updateWarningMutex.Lock()
	defer fake.updateWarningMutex.Unlock()
	fake.UpdateWarningStub = nil
	if fake.updateWarningReturnsOnCall == nil {
		fake.updateWarningReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateWarningReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerServer) UseProject(arg1 string) lxd.InstanceServer {
	fake.useProjectMutex.Lock()
	ret, specificReturn := fake.useProjectReturnsOnCall[len(fake.useProjectArgsForCall)]
	fake.useProjectArgsForCall = append(fake.useProjectArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UseProjectStub
	fakeReturns := fake.useProjectReturns
	fake.recordInvocation("UseProject", []interface{}{arg1})
	fake.useProjectMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UseProjectCallCount() int {
	fake.useProjectMutex.RLock()
	defer fake.useProjectMutex.RUnlock()
	return len(fake.useProjectArgsForCall)
}

func (fake *FakeContainerServer) UseProjectCalls(stub func(string) lxd.InstanceServer) {
	fake.useProjectMutex.Lock()
	defer fake.useProjectMutex.Unlock()
	fake.UseProjectStub = stub
}

func (fake *FakeContainerServer) UseProjectArgsForCall(i int) string {
	fake.useProjectMutex.RLock()
	defer fake.useProjectMutex.RUnlock()
	argsForCall := fake.useProjectArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) UseProjectReturns(result1 lxd.InstanceServer) {
	fake.useProjectMutex.Lock()
	defer fake.useProjectMutex.Unlock()
	fake.UseProjectStub = nil
	fake.useProjectReturns = struct {
		result1 lxd.InstanceServer
	}{result1}
}

func (fake *FakeContainerServer) UseProjectReturnsOnCall(i int, result1 lxd.InstanceServer) {
	fake.useProjectMutex.Lock()
	defer fake.useProjectMutex.Unlock()
	fake.UseProjectStub = nil
	if fake.useProjectReturnsOnCall == nil {
		fake.useProjectReturnsOnCall = make(map[int]struct {
			result1 lxd.InstanceServer
		})
	}
	fake.useProjectReturnsOnCall[i] = struct {
		result1 lxd.InstanceServer
	}{result1}
}

func (fake *FakeContainerServer) UseTarget(arg1 string) lxd.InstanceServer {
	fake.useTargetMutex.Lock()
	ret, specificReturn := fake.useTargetReturnsOnCall[len(fake.useTargetArgsForCall)]
	fake.useTargetArgsForCall = append(fake.useTargetArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UseTargetStub
	fakeReturns := fake.useTargetReturns
	fake.recordInvocation("UseTarget", []interface{}{arg1})
	fake.useTargetMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerServer) UseTargetCallCount() int {
	fake.useTargetMutex.RLock()
	defer fake.useTargetMutex.RUnlock()
	return len(fake.useTargetArgsForCall)
}

func (fake *FakeContainerServer) UseTargetCalls(stub func(string) lxd.InstanceServer) {
	fake.useTargetMutex.Lock()
	defer fake.useTargetMutex.Unlock()
	fake.UseTargetStub = stub
}

func (fake *FakeContainerServer) UseTargetArgsForCall(i int) string {
	fake.useTargetMutex.RLock()
	defer fake.useTargetMutex.RUnlock()
	argsForCall := fake.useTargetArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerServer) UseTargetReturns(result1 lxd.InstanceServer) {
	fake.useTargetMutex.Lock()
	defer fake.useTargetMutex.Unlock()
	fake.UseTargetStub = nil
	fake.useTargetReturns = struct {
		result1 lxd.InstanceServer
	}{result1}
}

func (fake *FakeContainerServer) UseTargetReturnsOnCall(i int, result1 lxd.InstanceServer) {
	fake.useTargetMutex.Lock()
	defer fake.useTargetMutex.Unlock()
	fake.UseTargetStub = nil
	if fake.useTargetReturnsOnCall == nil {
		fake.useTargetReturnsOnCall = make(map[int]struct {
			result1 lxd.InstanceServer
		})
	}
	fake.useTargetReturnsOnCall[i] = struct {
		result1 lxd.InstanceServer
	}{result1}
}

func (fake *FakeContainerServer) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.consoleContainerMutex.RLock()
	defer fake.consoleContainerMutex.RUnlock()
	fake.consoleInstanceMutex.RLock()
	defer fake.consoleInstanceMutex.RUnlock()
	fake.consoleInstanceDynamicMutex.RLock()
	defer fake.consoleInstanceDynamicMutex.RUnlock()
	fake.copyContainerMutex.RLock()
	defer fake.copyContainerMutex.RUnlock()
	fake.copyContainerSnapshotMutex.RLock()
	defer fake.copyContainerSnapshotMutex.RUnlock()
	fake.copyImageMutex.RLock()
	defer fake.copyImageMutex.RUnlock()
	fake.copyInstanceMutex.RLock()
	defer fake.copyInstanceMutex.RUnlock()
	fake.copyInstanceSnapshotMutex.RLock()
	defer fake.copyInstanceSnapshotMutex.RUnlock()
	fake.copyStoragePoolVolumeMutex.RLock()
	defer fake.copyStoragePoolVolumeMutex.RUnlock()
	fake.createCertificateMutex.RLock()
	defer fake.createCertificateMutex.RUnlock()
	fake.createCertificateTokenMutex.RLock()
	defer fake.createCertificateTokenMutex.RUnlock()
	fake.createClusterGroupMutex.RLock()
	defer fake.createClusterGroupMutex.RUnlock()
	fake.createClusterMemberMutex.RLock()
	defer fake.createClusterMemberMutex.RUnlock()
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	fake.createContainerBackupMutex.RLock()
	defer fake.createContainerBackupMutex.RUnlock()
	fake.createContainerFileMutex.RLock()
	defer fake.createContainerFileMutex.RUnlock()
	fake.createContainerFromBackupMutex.RLock()
	defer fake.createContainerFromBackupMutex.RUnlock()
	fake.createContainerFromImageMutex.RLock()
	defer fake.createContainerFromImageMutex.RUnlock()
	fake.createContainerSnapshotMutex.RLock()
	defer fake.createContainerSnapshotMutex.RUnlock()
	fake.createContainerTemplateFileMutex.RLock()
	defer fake.createContainerTemplateFileMutex.RUnlock()
	fake.createImageMutex.RLock()
	defer fake.createImageMutex.RUnlock()
	fake.createImageAliasMutex.RLock()
	defer fake.createImageAliasMutex.RUnlock()
	fake.createImageSecretMutex.RLock()
	defer fake.createImageSecretMutex.RUnlock()
	fake.createInstanceMutex.RLock()
	defer fake.createInstanceMutex.RUnlock()
	fake.createInstanceBackupMutex.RLock()
	defer fake.createInstanceBackupMutex.RUnlock()
	fake.createInstanceFileMutex.RLock()
	defer fake.createInstanceFileMutex.RUnlock()
	fake.createInstanceFromBackupMutex.RLock()
	defer fake.createInstanceFromBackupMutex.RUnlock()
	fake.createInstanceFromImageMutex.RLock()
	defer fake.createInstanceFromImageMutex.RUnlock()
	fake.createInstanceSnapshotMutex.RLock()
	defer fake.createInstanceSnapshotMutex.RUnlock()
	fake.createInstanceTemplateFileMutex.RLock()
	defer fake.createInstanceTemplateFileMutex.RUnlock()
	fake.createNetworkMutex.RLock()
	defer fake.createNetworkMutex.RUnlock()
	fake.createNetworkACLMutex.RLock()
	defer fake.createNetworkACLMutex.RUnlock()
	fake.createNetworkForwardMutex.RLock()
	defer fake.createNetworkForwardMutex.RUnlock()
	fake.createNetworkLoadBalancerMutex.RLock()
	defer fake.createNetworkLoadBalancerMutex.RUnlock()
	fake.createNetworkPeerMutex.RLock()
	defer fake.createNetworkPeerMutex.RUnlock()
	fake.createNetworkZoneMutex.RLock()
	defer fake.createNetworkZoneMutex.RUnlock()
	fake.createNetworkZoneRecordMutex.RLock()
	defer fake.createNetworkZoneRecordMutex.RUnlock()
	fake.createProfileMutex.RLock()
	defer fake.createProfileMutex.RUnlock()
	fake.createProjectMutex.RLock()
	defer fake.createProjectMutex.RUnlock()
	fake.createStoragePoolMutex.RLock()
	defer fake.createStoragePoolMutex.RUnlock()
	fake.createStoragePoolVolumeMutex.RLock()
	defer fake.createStoragePoolVolumeMutex.RUnlock()
	fake.createStoragePoolVolumeBackupMutex.RLock()
	defer fake.createStoragePoolVolumeBackupMutex.RUnlock()
	fake.createStoragePoolVolumeFromBackupMutex.RLock()
	defer fake.createStoragePoolVolumeFromBackupMutex.RUnlock()
	fake.createStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.createStoragePoolVolumeSnapshotMutex.RUnlock()
	fake.deleteCertificateMutex.RLock()
	defer fake.deleteCertificateMutex.RUnlock()
	fake.deleteClusterGroupMutex.RLock()
	defer fake.deleteClusterGroupMutex.RUnlock()
	fake.deleteClusterMemberMutex.RLock()
	defer fake.deleteClusterMemberMutex.RUnlock()
	fake.deleteContainerMutex.RLock()
	defer fake.deleteContainerMutex.RUnlock()
	fake.deleteContainerBackupMutex.RLock()
	defer fake.deleteContainerBackupMutex.RUnlock()
	fake.deleteContainerConsoleLogMutex.RLock()
	defer fake.deleteContainerConsoleLogMutex.RUnlock()
	fake.deleteContainerFileMutex.RLock()
	defer fake.deleteContainerFileMutex.RUnlock()
	fake.deleteContainerLogfileMutex.RLock()
	defer fake.deleteContainerLogfileMutex.RUnlock()
	fake.deleteContainerSnapshotMutex.RLock()
	defer fake.deleteContainerSnapshotMutex.RUnlock()
	fake.deleteContainerTemplateFileMutex.RLock()
	defer fake.deleteContainerTemplateFileMutex.RUnlock()
	fake.deleteImageMutex.RLock()
	defer fake.deleteImageMutex.RUnlock()
	fake.deleteImageAliasMutex.RLock()
	defer fake.deleteImageAliasMutex.RUnlock()
	fake.deleteInstanceMutex.RLock()
	defer fake.deleteInstanceMutex.RUnlock()
	fake.deleteInstanceBackupMutex.RLock()
	defer fake.deleteInstanceBackupMutex.RUnlock()
	fake.deleteInstanceConsoleLogMutex.RLock()
	defer fake.deleteInstanceConsoleLogMutex.RUnlock()
	fake.deleteInstanceFileMutex.RLock()
	defer fake.deleteInstanceFileMutex.RUnlock()
	fake.deleteInstanceLogfileMutex.RLock()
	defer fake.deleteInstanceLogfileMutex.RUnlock()
	fake.deleteInstanceSnapshotMutex.RLock()
	defer fake.deleteInstanceSnapshotMutex.RUnlock()
	fake.deleteInstanceTemplateFileMutex.RLock()
	defer fake.deleteInstanceTemplateFileMutex.RUnlock()
	fake.deleteNetworkMutex.RLock()
	defer fake.deleteNetworkMutex.RUnlock()
	fake.deleteNetworkACLMutex.RLock()
	defer fake.deleteNetworkACLMutex.RUnlock()
	fake.deleteNetworkForwardMutex.RLock()
	defer fake.deleteNetworkForwardMutex.RUnlock()
	fake.deleteNetworkLoadBalancerMutex.RLock()
	defer fake.deleteNetworkLoadBalancerMutex.RUnlock()
	fake.deleteNetworkPeerMutex.RLock()
	defer fake.deleteNetworkPeerMutex.RUnlock()
	fake.deleteNetworkZoneMutex.RLock()
	defer fake.deleteNetworkZoneMutex.RUnlock()
	fake.deleteNetworkZoneRecordMutex.RLock()
	defer fake.deleteNetworkZoneRecordMutex.RUnlock()
	fake.deleteOperationMutex.RLock()
	defer fake.deleteOperationMutex.RUnlock()
	fake.deleteProfileMutex.RLock()
	defer fake.deleteProfileMutex.RUnlock()
	fake.deleteProjectMutex.RLock()
	defer fake.deleteProjectMutex.RUnlock()
	fake.deleteStoragePoolMutex.RLock()
	defer fake.deleteStoragePoolMutex.RUnlock()
	fake.deleteStoragePoolVolumeMutex.RLock()
	defer fake.deleteStoragePoolVolumeMutex.RUnlock()
	fake.deleteStoragePoolVolumeBackupMutex.RLock()
	defer fake.deleteStoragePoolVolumeBackupMutex.RUnlock()
	fake.deleteStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.deleteStoragePoolVolumeSnapshotMutex.RUnlock()
	fake.deleteWarningMutex.RLock()
	defer fake.deleteWarningMutex.RUnlock()
	fake.disconnectMutex.RLock()
	defer fake.disconnectMutex.RUnlock()
	fake.doHTTPMutex.RLock()
	defer fake.doHTTPMutex.RUnlock()
	fake.execContainerMutex.RLock()
	defer fake.execContainerMutex.RUnlock()
	fake.execInstanceMutex.RLock()
	defer fake.execInstanceMutex.RUnlock()
	fake.exportImageMutex.RLock()
	defer fake.exportImageMutex.RUnlock()
	fake.getCertificateMutex.RLock()
	defer fake.getCertificateMutex.RUnlock()
	fake.getCertificateFingerprintsMutex.RLock()
	defer fake.getCertificateFingerprintsMutex.RUnlock()
	fake.getCertificatesMutex.RLock()
	defer fake.getCertificatesMutex.RUnlock()
	fake.getClusterMutex.RLock()
	defer fake.getClusterMutex.RUnlock()
	fake.getClusterGroupMutex.RLock()
	defer fake.getClusterGroupMutex.RUnlock()
	fake.getClusterGroupNamesMutex.RLock()
	defer fake.getClusterGroupNamesMutex.RUnlock()
	fake.getClusterGroupsMutex.RLock()
	defer fake.getClusterGroupsMutex.RUnlock()
	fake.getClusterMemberMutex.RLock()
	defer fake.getClusterMemberMutex.RUnlock()
	fake.getClusterMemberNamesMutex.RLock()
	defer fake.getClusterMemberNamesMutex.RUnlock()
	fake.getClusterMembersMutex.RLock()
	defer fake.getClusterMembersMutex.RUnlock()
	fake.getConnectionInfoMutex.RLock()
	defer fake.getConnectionInfoMutex.RUnlock()
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	fake.getContainerBackupMutex.RLock()
	defer fake.getContainerBackupMutex.RUnlock()
	fake.getContainerBackupFileMutex.RLock()
	defer fake.getContainerBackupFileMutex.RUnlock()
	fake.getContainerBackupNamesMutex.RLock()
	defer fake.getContainerBackupNamesMutex.RUnlock()
	fake.getContainerBackupsMutex.RLock()
	defer fake.getContainerBackupsMutex.RUnlock()
	fake.getContainerConsoleLogMutex.RLock()
	defer fake.getContainerConsoleLogMutex.RUnlock()
	fake.getContainerFileMutex.RLock()
	defer fake.getContainerFileMutex.RUnlock()
	fake.getContainerLogfileMutex.RLock()
	defer fake.getContainerLogfileMutex.RUnlock()
	fake.getContainerLogfilesMutex.RLock()
	defer fake.getContainerLogfilesMutex.RUnlock()
	fake.getContainerMetadataMutex.RLock()
	defer fake.getContainerMetadataMutex.RUnlock()
	fake.getContainerNamesMutex.RLock()
	defer fake.getContainerNamesMutex.RUnlock()
	fake.getContainerSnapshotMutex.RLock()
	defer fake.getContainerSnapshotMutex.RUnlock()
	fake.getContainerSnapshotNamesMutex.RLock()
	defer fake.getContainerSnapshotNamesMutex.RUnlock()
	fake.getContainerSnapshotsMutex.RLock()
	defer fake.getContainerSnapshotsMutex.RUnlock()
	fake.getContainerStateMutex.RLock()
	defer fake.getContainerStateMutex.RUnlock()
	fake.getContainerTemplateFileMutex.RLock()
	defer fake.getContainerTemplateFileMutex.RUnlock()
	fake.getContainerTemplateFilesMutex.RLock()
	defer fake.getContainerTemplateFilesMutex.RUnlock()
	fake.getContainersMutex.RLock()
	defer fake.getContainersMutex.RUnlock()
	fake.getContainersFullMutex.RLock()
	defer fake.getContainersFullMutex.RUnlock()
	fake.getEventsMutex.RLock()
	defer fake.getEventsMutex.RUnlock()
	fake.getEventsAllProjectsMutex.RLock()
	defer fake.getEventsAllProjectsMutex.RUnlock()
	fake.getHTTPClientMutex.RLock()
	defer fake.getHTTPClientMutex.RUnlock()
	fake.getImageMutex.RLock()
	defer fake.getImageMutex.RUnlock()
	fake.getImageAliasMutex.RLock()
	defer fake.getImageAliasMutex.RUnlock()
	fake.getImageAliasArchitecturesMutex.RLock()
	defer fake.getImageAliasArchitecturesMutex.RUnlock()
	fake.getImageAliasNamesMutex.RLock()
	defer fake.getImageAliasNamesMutex.RUnlock()
	fake.getImageAliasTypeMutex.RLock()
	defer fake.getImageAliasTypeMutex.RUnlock()
	fake.getImageAliasesMutex.RLock()
	defer fake.getImageAliasesMutex.RUnlock()
	fake.getImageFileMutex.RLock()
	defer fake.getImageFileMutex.RUnlock()
	fake.getImageFingerprintsMutex.RLock()
	defer fake.getImageFingerprintsMutex.RUnlock()
	fake.getImageSecretMutex.RLock()
	defer fake.getImageSecretMutex.RUnlock()
	fake.getImagesMutex.RLock()
	defer fake.getImagesMutex.RUnlock()
	fake.getImagesWithFilterMutex.RLock()
	defer fake.getImagesWithFilterMutex.RUnlock()
	fake.getInstanceMutex.RLock()
	defer fake.getInstanceMutex.RUnlock()
	fake.getInstanceBackupMutex.RLock()
	defer fake.getInstanceBackupMutex.RUnlock()
	fake.getInstanceBackupFileMutex.RLock()
	defer fake.getInstanceBackupFileMutex.RUnlock()
	fake.getInstanceBackupNamesMutex.RLock()
	defer fake.getInstanceBackupNamesMutex.RUnlock()
	fake.getInstanceBackupsMutex.RLock()
	defer fake.getInstanceBackupsMutex.RUnlock()
	fake.getInstanceConsoleLogMutex.RLock()
	defer fake.getInstanceConsoleLogMutex.RUnlock()
	fake.getInstanceFileMutex.RLock()
	defer fake.getInstanceFileMutex.RUnlock()
	fake.getInstanceFileSFTPMutex.RLock()
	defer fake.getInstanceFileSFTPMutex.RUnlock()
	fake.getInstanceFileSFTPConnMutex.RLock()
	defer fake.getInstanceFileSFTPConnMutex.RUnlock()
	fake.getInstanceFullMutex.RLock()
	defer fake.getInstanceFullMutex.RUnlock()
	fake.getInstanceLogfileMutex.RLock()
	defer fake.getInstanceLogfileMutex.RUnlock()
	fake.getInstanceLogfilesMutex.RLock()
	defer fake.getInstanceLogfilesMutex.RUnlock()
	fake.getInstanceMetadataMutex.RLock()
	defer fake.getInstanceMetadataMutex.RUnlock()
	fake.getInstanceNamesMutex.RLock()
	defer fake.getInstanceNamesMutex.RUnlock()
	fake.getInstanceNamesAllProjectsMutex.RLock()
	defer fake.getInstanceNamesAllProjectsMutex.RUnlock()
	fake.getInstanceSnapshotMutex.RLock()
	defer fake.getInstanceSnapshotMutex.RUnlock()
	fake.getInstanceSnapshotNamesMutex.RLock()
	defer fake.getInstanceSnapshotNamesMutex.RUnlock()
	fake.getInstanceSnapshotsMutex.RLock()
	defer fake.getInstanceSnapshotsMutex.RUnlock()
	fake.getInstanceStateMutex.RLock()
	defer fake.getInstanceStateMutex.RUnlock()
	fake.getInstanceTemplateFileMutex.RLock()
	defer fake.getInstanceTemplateFileMutex.RUnlock()
	fake.getInstanceTemplateFilesMutex.RLock()
	defer fake.getInstanceTemplateFilesMutex.RUnlock()
	fake.getInstancesMutex.RLock()
	defer fake.getInstancesMutex.RUnlock()
	fake.getInstancesAllProjectsMutex.RLock()
	defer fake.getInstancesAllProjectsMutex.RUnlock()
	fake.getInstancesAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesAllProjectsWithFilterMutex.RUnlock()
	fake.getInstancesFullMutex.RLock()
	defer fake.getInstancesFullMutex.RUnlock()
	fake.getInstancesFullAllProjectsMutex.RLock()
	defer fake.getInstancesFullAllProjectsMutex.RUnlock()
	fake.getInstancesFullAllProjectsWithFilterMutex.RLock()
	defer fake.getInstancesFullAllProjectsWithFilterMutex.RUnlock()
	fake.getInstancesFullWithFilterMutex.RLock()
	defer fake.getInstancesFullWithFilterMutex.RUnlock()
	fake.getInstancesWithFilterMutex.RLock()
	defer fake.getInstancesWithFilterMutex.RUnlock()
	fake.getMetricsMutex.RLock()
	defer fake.getMetricsMutex.RUnlock()
	fake.getNetworkMutex.RLock()
	defer fake.getNetworkMutex.RUnlock()
	fake.getNetworkACLMutex.RLock()
	defer fake.getNetworkACLMutex.RUnlock()
	fake.getNetworkACLLogfileMutex.RLock()
	defer fake.getNetworkACLLogfileMutex.RUnlock()
	fake.getNetworkACLNamesMutex.RLock()
	defer fake.getNetworkACLNamesMutex.RUnlock()
	fake.getNetworkACLsMutex.RLock()
	defer fake.getNetworkACLsMutex.RUnlock()
	fake.getNetworkForwardMutex.RLock()
	defer fake.getNetworkForwardMutex.RUnlock()
	fake.getNetworkForwardAddressesMutex.RLock()
	defer fake.getNetworkForwardAddressesMutex.RUnlock()
	fake.getNetworkForwardsMutex.RLock()
	defer fake.getNetworkForwardsMutex.RUnlock()
	fake.getNetworkLeasesMutex.RLock()
	defer fake.getNetworkLeasesMutex.RUnlock()
	fake.getNetworkLoadBalancerMutex.RLock()
	defer fake.getNetworkLoadBalancerMutex.RUnlock()
	fake.getNetworkLoadBalancerAddressesMutex.RLock()
	defer fake.getNetworkLoadBalancerAddressesMutex.RUnlock()
	fake.getNetworkLoadBalancersMutex.RLock()
	defer fake.getNetworkLoadBalancersMutex.RUnlock()
	fake.getNetworkNamesMutex.RLock()
	defer fake.getNetworkNamesMutex.RUnlock()
	fake.getNetworkPeerMutex.RLock()
	defer fake.getNetworkPeerMutex.RUnlock()
	fake.getNetworkPeerNamesMutex.RLock()
	defer fake.getNetworkPeerNamesMutex.RUnlock()
	fake.getNetworkPeersMutex.RLock()
	defer fake.getNetworkPeersMutex.RUnlock()
	fake.getNetworkStateMutex.RLock()
	defer fake.getNetworkStateMutex.RUnlock()
	fake.getNetworkZoneMutex.RLock()
	defer fake.getNetworkZoneMutex.RUnlock()
	fake.getNetworkZoneNamesMutex.RLock()
	defer fake.getNetworkZoneNamesMutex.RUnlock()
	fake.getNetworkZoneRecordMutex.RLock()
	defer fake.getNetworkZoneRecordMutex.RUnlock()
	fake.getNetworkZoneRecordNamesMutex.RLock()
	defer fake.getNetworkZoneRecordNamesMutex.RUnlock()
	fake.getNetworkZoneRecordsMutex.RLock()
	defer fake.getNetworkZoneRecordsMutex.RUnlock()
	fake.getNetworkZonesMutex.RLock()
	defer fake.getNetworkZonesMutex.RUnlock()
	fake.getNetworksMutex.RLock()
	defer fake.getNetworksMutex.RUnlock()
	fake.getOperationMutex.RLock()
	defer fake.getOperationMutex.RUnlock()
	fake.getOperationUUIDsMutex.RLock()
	defer fake.getOperationUUIDsMutex.RUnlock()
	fake.getOperationWaitMutex.RLock()
	defer fake.getOperationWaitMutex.RUnlock()
	fake.getOperationWaitSecretMutex.RLock()
	defer fake.getOperationWaitSecretMutex.RUnlock()
	fake.getOperationWebsocketMutex.RLock()
	defer fake.getOperationWebsocketMutex.RUnlock()
	fake.getOperationsMutex.RLock()
	defer fake.getOperationsMutex.RUnlock()
	fake.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	fake.getPrivateImageFileMutex.RLock()
	defer fake.getPrivateImageFileMutex.RUnlock()
	fake.getProfileMutex.RLock()
	defer fake.getProfileMutex.RUnlock()
	fake.getProfileNamesMutex.RLock()
	defer fake.getProfileNamesMutex.RUnlock()
	fake.getProfilesMutex.RLock()
	defer fake.getProfilesMutex.RUnlock()
	fake.getProjectMutex.RLock()
	defer fake.getProjectMutex.RUnlock()
	fake.getProjectNamesMutex.RLock()
	defer fake.getProjectNamesMutex.RUnlock()
	fake.getProjectStateMutex.RLock()
	defer fake.getProjectStateMutex.RUnlock()
	fake.getProjectsMutex.RLock()
	defer fake.getProjectsMutex.RUnlock()
	fake.getServerMutex.RLock()
	defer fake.getServerMutex.RUnlock()
	fake.getServerResourcesMutex.RLock()
	defer fake.getServerResourcesMutex.RUnlock()
	fake.getStoragePoolMutex.RLock()
	defer fake.getStoragePoolMutex.RUnlock()
	fake.getStoragePoolNamesMutex.RLock()
	defer fake.getStoragePoolNamesMutex.RUnlock()
	fake.getStoragePoolResourcesMutex.RLock()
	defer fake.getStoragePoolResourcesMutex.RUnlock()
	fake.getStoragePoolVolumeMutex.RLock()
	defer fake.getStoragePoolVolumeMutex.RUnlock()
	fake.getStoragePoolVolumeBackupMutex.RLock()
	defer fake.getStoragePoolVolumeBackupMutex.RUnlock()
	fake.getStoragePoolVolumeBackupFileMutex.RLock()
	defer fake.getStoragePoolVolumeBackupFileMutex.RUnlock()
	fake.getStoragePoolVolumeBackupNamesMutex.RLock()
	defer fake.getStoragePoolVolumeBackupNamesMutex.RUnlock()
	fake.getStoragePoolVolumeBackupsMutex.RLock()
	defer fake.getStoragePoolVolumeBackupsMutex.RUnlock()
	fake.getStoragePoolVolumeNamesMutex.RLock()
	defer fake.getStoragePoolVolumeNamesMutex.RUnlock()
	fake.getStoragePoolVolumeNamesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumeNamesAllProjectsMutex.RUnlock()
	fake.getStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotMutex.RUnlock()
	fake.getStoragePoolVolumeSnapshotNamesMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotNamesMutex.RUnlock()
	fake.getStoragePoolVolumeSnapshotsMutex.RLock()
	defer fake.getStoragePoolVolumeSnapshotsMutex.RUnlock()
	fake.getStoragePoolVolumeStateMutex.RLock()
	defer fake.getStoragePoolVolumeStateMutex.RUnlock()
	fake.getStoragePoolVolumesMutex.RLock()
	defer fake.getStoragePoolVolumesMutex.RUnlock()
	fake.getStoragePoolVolumesAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesAllProjectsMutex.RUnlock()
	fake.getStoragePoolVolumesWithFilterMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterMutex.RUnlock()
	fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RLock()
	defer fake.getStoragePoolVolumesWithFilterAllProjectsMutex.RUnlock()
	fake.getStoragePoolsMutex.RLock()
	defer fake.getStoragePoolsMutex.RUnlock()
	fake.getWarningMutex.RLock()
	defer fake.getWarningMutex.RUnlock()
	fake.getWarningUUIDsMutex.RLock()
	defer fake.getWarningUUIDsMutex.RUnlock()
	fake.getWarningsMutex.RLock()
	defer fake.getWarningsMutex.RUnlock()
	fake.hasExtensionMutex.RLock()
	defer fake.hasExtensionMutex.RUnlock()
	fake.isClusteredMutex.RLock()
	defer fake.isClusteredMutex.RUnlock()
	fake.migrateContainerMutex.RLock()
	defer fake.migrateContainerMutex.RUnlock()
	fake.migrateContainerSnapshotMutex.RLock()
	defer fake.migrateContainerSnapshotMutex.RUnlock()
	fake.migrateInstanceMutex.RLock()
	defer fake.migrateInstanceMutex.RUnlock()
	fake.migrateInstanceSnapshotMutex.RLock()
	defer fake.migrateInstanceSnapshotMutex.RUnlock()
	fake.migrateStoragePoolVolumeMutex.RLock()
	defer fake.migrateStoragePoolVolumeMutex.RUnlock()
	fake.moveStoragePoolVolumeMutex.RLock()
	defer fake.moveStoragePoolVolumeMutex.RUnlock()
	fake.rawOperationMutex.RLock()
	defer fake.rawOperationMutex.RUnlock()
	fake.rawQueryMutex.RLock()
	defer fake.rawQueryMutex.RUnlock()
	fake.rawWebsocketMutex.RLock()
	defer fake.rawWebsocketMutex.RUnlock()
	fake.refreshImageMutex.RLock()
	defer fake.refreshImageMutex.RUnlock()
	fake.renameClusterGroupMutex.RLock()
	defer fake.renameClusterGroupMutex.RUnlock()
	fake.renameClusterMemberMutex.RLock()
	defer fake.renameClusterMemberMutex.RUnlock()
	fake.renameContainerMutex.RLock()
	defer fake.renameContainerMutex.RUnlock()
	fake.renameContainerBackupMutex.RLock()
	defer fake.renameContainerBackupMutex.RUnlock()
	fake.renameContainerSnapshotMutex.RLock()
	defer fake.renameContainerSnapshotMutex.RUnlock()
	fake.renameImageAliasMutex.RLock()
	defer fake.renameImageAliasMutex.RUnlock()
	fake.renameInstanceMutex.RLock()
	defer fake.renameInstanceMutex.RUnlock()
	fake.renameInstanceBackupMutex.RLock()
	defer fake.renameInstanceBackupMutex.RUnlock()
	fake.renameInstanceSnapshotMutex.RLock()
	defer fake.renameInstanceSnapshotMutex.RUnlock()
	fake.renameNetworkMutex.RLock()
	defer fake.renameNetworkMutex.RUnlock()
	fake.renameNetworkACLMutex.RLock()
	defer fake.renameNetworkACLMutex.RUnlock()
	fake.renameProfileMutex.RLock()
	defer fake.renameProfileMutex.RUnlock()
	fake.renameProjectMutex.RLock()
	defer fake.renameProjectMutex.RUnlock()
	fake.renameStoragePoolVolumeMutex.RLock()
	defer fake.renameStoragePoolVolumeMutex.RUnlock()
	fake.renameStoragePoolVolumeBackupMutex.RLock()
	defer fake.renameStoragePoolVolumeBackupMutex.RUnlock()
	fake.renameStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.renameStoragePoolVolumeSnapshotMutex.RUnlock()
	fake.requireAuthenticatedMutex.RLock()
	defer fake.requireAuthenticatedMutex.RUnlock()
	fake.sendEventMutex.RLock()
	defer fake.sendEventMutex.RUnlock()
	fake.setContainerMetadataMutex.RLock()
	defer fake.setContainerMetadataMutex.RUnlock()
	fake.updateCertificateMutex.RLock()
	defer fake.updateCertificateMutex.RUnlock()
	fake.updateClusterMutex.RLock()
	defer fake.updateClusterMutex.RUnlock()
	fake.updateClusterCertificateMutex.RLock()
	defer fake.updateClusterCertificateMutex.RUnlock()
	fake.updateClusterGroupMutex.RLock()
	defer fake.updateClusterGroupMutex.RUnlock()
	fake.updateClusterMemberMutex.RLock()
	defer fake.updateClusterMemberMutex.RUnlock()
	fake.updateClusterMemberStateMutex.RLock()
	defer fake.updateClusterMemberStateMutex.RUnlock()
	fake.updateContainerMutex.RLock()
	defer fake.updateContainerMutex.RUnlock()
	fake.updateContainerSnapshotMutex.RLock()
	defer fake.updateContainerSnapshotMutex.RUnlock()
	fake.updateContainerStateMutex.RLock()
	defer fake.updateContainerStateMutex.RUnlock()
	fake.updateContainerTemplateFileMutex.RLock()
	defer fake.updateContainerTemplateFileMutex.RUnlock()
	fake.updateImageMutex.RLock()
	defer fake.updateImageMutex.RUnlock()
	fake.updateImageAliasMutex.RLock()
	defer fake.updateImageAliasMutex.RUnlock()
	fake.updateInstanceMutex.RLock()
	defer fake.updateInstanceMutex.RUnlock()
	fake.updateInstanceMetadataMutex.RLock()
	defer fake.updateInstanceMetadataMutex.RUnlock()
	fake.updateInstanceSnapshotMutex.RLock()
	defer fake.updateInstanceSnapshotMutex.RUnlock()
	fake.updateInstanceStateMutex.RLock()
	defer fake.updateInstanceStateMutex.RUnlock()
	fake.updateInstancesMutex.RLock()
	defer fake.updateInstancesMutex.RUnlock()
	fake.updateNetworkMutex.RLock()
	defer fake.updateNetworkMutex.RUnlock()
	fake.updateNetworkACLMutex.RLock()
	defer fake.updateNetworkACLMutex.RUnlock()
	fake.updateNetworkForwardMutex.RLock()
	defer fake.updateNetworkForwardMutex.RUnlock()
	fake.updateNetworkLoadBalancerMutex.RLock()
	defer fake.updateNetworkLoadBalancerMutex.RUnlock()
	fake.updateNetworkPeerMutex.RLock()
	defer fake.updateNetworkPeerMutex.RUnlock()
	fake.updateNetworkZoneMutex.RLock()
	defer fake.updateNetworkZoneMutex.RUnlock()
	fake.updateNetworkZoneRecordMutex.RLock()
	defer fake.updateNetworkZoneRecordMutex.RUnlock()
	fake.updateProfileMutex.RLock()
	defer fake.updateProfileMutex.RUnlock()
	fake.updateProjectMutex.RLock()
	defer fake.updateProjectMutex.RUnlock()
	fake.updateServerMutex.RLock()
	defer fake.updateServerMutex.RUnlock()
	fake.updateStoragePoolMutex.RLock()
	defer fake.updateStoragePoolMutex.RUnlock()
	fake.updateStoragePoolVolumeMutex.RLock()
	defer fake.updateStoragePoolVolumeMutex.RUnlock()
	fake.updateStoragePoolVolumeSnapshotMutex.RLock()
	defer fake.updateStoragePoolVolumeSnapshotMutex.RUnlock()
	fake.updateWarningMutex.RLock()
	defer fake.updateWarningMutex.RUnlock()
	fake.useProjectMutex.RLock()
	defer fake.useProjectMutex.RUnlock()
	fake.useTargetMutex.RLock()
	defer fake.useTargetMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeContainerServer) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ lxd.ContainerServer = new(FakeContainerServer)
