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

import (
	"net/http"
	"sync"

	lxd "github.com/lxc/lxd/client"
	"github.com/lxc/lxd/shared/api"
)

type FakeImageServer struct {
	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
	}
	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
	}
	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
	}
	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
	}
	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
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeImageServer) 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 *FakeImageServer) DisconnectCallCount() int {
	fake.disconnectMutex.RLock()
	defer fake.disconnectMutex.RUnlock()
	return len(fake.disconnectArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) DoHTTPCallCount() int {
	fake.doHTTPMutex.RLock()
	defer fake.doHTTPMutex.RUnlock()
	return len(fake.doHTTPArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) ExportImageCallCount() int {
	fake.exportImageMutex.RLock()
	defer fake.exportImageMutex.RUnlock()
	return len(fake.exportImageArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetConnectionInfoCallCount() int {
	fake.getConnectionInfoMutex.RLock()
	defer fake.getConnectionInfoMutex.RUnlock()
	return len(fake.getConnectionInfoArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetHTTPClientCallCount() int {
	fake.getHTTPClientMutex.RLock()
	defer fake.getHTTPClientMutex.RUnlock()
	return len(fake.getHTTPClientArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageCallCount() int {
	fake.getImageMutex.RLock()
	defer fake.getImageMutex.RUnlock()
	return len(fake.getImageArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageAliasCallCount() int {
	fake.getImageAliasMutex.RLock()
	defer fake.getImageAliasMutex.RUnlock()
	return len(fake.getImageAliasArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageAliasArchitecturesCallCount() int {
	fake.getImageAliasArchitecturesMutex.RLock()
	defer fake.getImageAliasArchitecturesMutex.RUnlock()
	return len(fake.getImageAliasArchitecturesArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageAliasNamesCallCount() int {
	fake.getImageAliasNamesMutex.RLock()
	defer fake.getImageAliasNamesMutex.RUnlock()
	return len(fake.getImageAliasNamesArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageAliasTypeCallCount() int {
	fake.getImageAliasTypeMutex.RLock()
	defer fake.getImageAliasTypeMutex.RUnlock()
	return len(fake.getImageAliasTypeArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageAliasesCallCount() int {
	fake.getImageAliasesMutex.RLock()
	defer fake.getImageAliasesMutex.RUnlock()
	return len(fake.getImageAliasesArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageFileCallCount() int {
	fake.getImageFileMutex.RLock()
	defer fake.getImageFileMutex.RUnlock()
	return len(fake.getImageFileArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageFingerprintsCallCount() int {
	fake.getImageFingerprintsMutex.RLock()
	defer fake.getImageFingerprintsMutex.RUnlock()
	return len(fake.getImageFingerprintsArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImageSecretCallCount() int {
	fake.getImageSecretMutex.RLock()
	defer fake.getImageSecretMutex.RUnlock()
	return len(fake.getImageSecretArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImagesCallCount() int {
	fake.getImagesMutex.RLock()
	defer fake.getImagesMutex.RUnlock()
	return len(fake.getImagesArgsForCall)
}

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetImagesWithFilterCallCount() int {
	fake.getImagesWithFilterMutex.RLock()
	defer fake.getImagesWithFilterMutex.RUnlock()
	return len(fake.getImagesWithFilterArgsForCall)
}

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

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

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetPrivateImageCallCount() int {
	fake.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	return len(fake.getPrivateImageArgsForCall)
}

func (fake *FakeImageServer) GetPrivateImageCalls(stub func(string, string) (*api.Image, string, error)) {
	fake.getPrivateImageMutex.Lock()
	defer fake.getPrivateImageMutex.Unlock()
	fake.GetPrivateImageStub = stub
}

func (fake *FakeImageServer) GetPrivateImageArgsForCall(i int) (string, string) {
	fake.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	argsForCall := fake.getPrivateImageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) GetPrivateImageFileCallCount() int {
	fake.getPrivateImageFileMutex.RLock()
	defer fake.getPrivateImageFileMutex.RUnlock()
	return len(fake.getPrivateImageFileArgsForCall)
}

func (fake *FakeImageServer) GetPrivateImageFileCalls(stub func(string, string, lxd.ImageFileRequest) (*lxd.ImageFileResponse, error)) {
	fake.getPrivateImageFileMutex.Lock()
	defer fake.getPrivateImageFileMutex.Unlock()
	fake.GetPrivateImageFileStub = stub
}

func (fake *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) 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 *FakeImageServer) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.disconnectMutex.RLock()
	defer fake.disconnectMutex.RUnlock()
	fake.doHTTPMutex.RLock()
	defer fake.doHTTPMutex.RUnlock()
	fake.exportImageMutex.RLock()
	defer fake.exportImageMutex.RUnlock()
	fake.getConnectionInfoMutex.RLock()
	defer fake.getConnectionInfoMutex.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.getPrivateImageMutex.RLock()
	defer fake.getPrivateImageMutex.RUnlock()
	fake.getPrivateImageFileMutex.RLock()
	defer fake.getPrivateImageFileMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeImageServer) 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.ImageServer = new(FakeImageServer)
