mockdocker.go

// Code generated by MockGen. DO NOT EDIT.
// Source: /home/ubuntu/workspace/code/go/src/github.com/docker/docker/client/interface.go

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

import (
	io "io"
	reflect "reflect"
	time "time"

	types "github.com/docker/docker/api/types"
	containerpkg "github.com/docker/docker/api/types/container"
	events "github.com/docker/docker/api/types/events"
	filters "github.com/docker/docker/api/types/filters"
	imagepkg "github.com/docker/docker/api/types/image"
	network "github.com/docker/docker/api/types/network"
	registry "github.com/docker/docker/api/types/registry"
	swarm "github.com/docker/docker/api/types/swarm"
	volume "github.com/docker/docker/api/types/volume"
	gomock "github.com/golang/mock/gomock"
	context "golang.org/x/net/context"
)

// MockCommonAPIClient is a mock of CommonAPIClient interface
type MockCommonAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockCommonAPIClientMockRecorder
}

// MockCommonAPIClientMockRecorder is the mock recorder for MockCommonAPIClient
type MockCommonAPIClientMockRecorder struct {
	mock *MockCommonAPIClient
}

// NewMockCommonAPIClient creates a new mock instance
func NewMockCommonAPIClient(ctrl *gomock.Controller) *MockCommonAPIClient {
	mock := &MockCommonAPIClient{ctrl: ctrl}
	mock.recorder = &MockCommonAPIClientMockRecorder{mock}
	return mock
}

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

// ContainerAttach mocks base method
func (m *MockCommonAPIClient) ContainerAttach(ctx context.Context, container string, options types.ContainerAttachOptions) (types.HijackedResponse, error) {
	ret := m.ctrl.Call(m, "ContainerAttach", ctx, container, options)
	ret0, _ := ret[0].(types.HijackedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerAttach indicates an expected call of ContainerAttach
func (mr *MockCommonAPIClientMockRecorder) ContainerAttach(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerAttach", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerAttach), ctx, container, options)
}

// ContainerCommit mocks base method
func (m *MockCommonAPIClient) ContainerCommit(ctx context.Context, container string, options types.ContainerCommitOptions) (types.IDResponse, error) {
	ret := m.ctrl.Call(m, "ContainerCommit", ctx, container, options)
	ret0, _ := ret[0].(types.IDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerCommit indicates an expected call of ContainerCommit
func (mr *MockCommonAPIClientMockRecorder) ContainerCommit(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerCommit", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerCommit), ctx, container, options)
}

// ContainerCreate mocks base method
func (m *MockCommonAPIClient) ContainerCreate(ctx context.Context, config *containerpkg.Config, hostConfig *containerpkg.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (containerpkg.ContainerCreateCreatedBody, error) {
	ret := m.ctrl.Call(m, "ContainerCreate", ctx, config, hostConfig, networkingConfig, containerName)
	ret0, _ := ret[0].(containerpkg.ContainerCreateCreatedBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerCreate indicates an expected call of ContainerCreate
func (mr *MockCommonAPIClientMockRecorder) ContainerCreate(ctx, config, hostConfig, networkingConfig, containerName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerCreate), ctx, config, hostConfig, networkingConfig, containerName)
}

// ContainerDiff mocks base method
func (m *MockCommonAPIClient) ContainerDiff(ctx context.Context, container string) ([]containerpkg.ContainerChangeResponseItem, error) {
	ret := m.ctrl.Call(m, "ContainerDiff", ctx, container)
	ret0, _ := ret[0].([]containerpkg.ContainerChangeResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerDiff indicates an expected call of ContainerDiff
func (mr *MockCommonAPIClientMockRecorder) ContainerDiff(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerDiff", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerDiff), ctx, container)
}

// ContainerExecAttach mocks base method
func (m *MockCommonAPIClient) ContainerExecAttach(ctx context.Context, execID string, config types.ExecConfig) (types.HijackedResponse, error) {
	ret := m.ctrl.Call(m, "ContainerExecAttach", ctx, execID, config)
	ret0, _ := ret[0].(types.HijackedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecAttach indicates an expected call of ContainerExecAttach
func (mr *MockCommonAPIClientMockRecorder) ContainerExecAttach(ctx, execID, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecAttach", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExecAttach), ctx, execID, config)
}

// ContainerExecCreate mocks base method
func (m *MockCommonAPIClient) ContainerExecCreate(ctx context.Context, container string, config types.ExecConfig) (types.IDResponse, error) {
	ret := m.ctrl.Call(m, "ContainerExecCreate", ctx, container, config)
	ret0, _ := ret[0].(types.IDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecCreate indicates an expected call of ContainerExecCreate
func (mr *MockCommonAPIClientMockRecorder) ContainerExecCreate(ctx, container, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExecCreate), ctx, container, config)
}

// ContainerExecInspect mocks base method
func (m *MockCommonAPIClient) ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error) {
	ret := m.ctrl.Call(m, "ContainerExecInspect", ctx, execID)
	ret0, _ := ret[0].(types.ContainerExecInspect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecInspect indicates an expected call of ContainerExecInspect
func (mr *MockCommonAPIClientMockRecorder) ContainerExecInspect(ctx, execID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecInspect", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExecInspect), ctx, execID)
}

// ContainerExecResize mocks base method
func (m *MockCommonAPIClient) ContainerExecResize(ctx context.Context, execID string, options types.ResizeOptions) error {
	ret := m.ctrl.Call(m, "ContainerExecResize", ctx, execID, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerExecResize indicates an expected call of ContainerExecResize
func (mr *MockCommonAPIClientMockRecorder) ContainerExecResize(ctx, execID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecResize", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExecResize), ctx, execID, options)
}

// ContainerExecStart mocks base method
func (m *MockCommonAPIClient) ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error {
	ret := m.ctrl.Call(m, "ContainerExecStart", ctx, execID, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerExecStart indicates an expected call of ContainerExecStart
func (mr *MockCommonAPIClientMockRecorder) ContainerExecStart(ctx, execID, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecStart", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExecStart), ctx, execID, config)
}

// ContainerExport mocks base method
func (m *MockCommonAPIClient) ContainerExport(ctx context.Context, container string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ContainerExport", ctx, container)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExport indicates an expected call of ContainerExport
func (mr *MockCommonAPIClientMockRecorder) ContainerExport(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExport", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerExport), ctx, container)
}

// ContainerInspect mocks base method
func (m *MockCommonAPIClient) ContainerInspect(ctx context.Context, container string) (types.ContainerJSON, error) {
	ret := m.ctrl.Call(m, "ContainerInspect", ctx, container)
	ret0, _ := ret[0].(types.ContainerJSON)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerInspect indicates an expected call of ContainerInspect
func (mr *MockCommonAPIClientMockRecorder) ContainerInspect(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInspect", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerInspect), ctx, container)
}

// ContainerInspectWithRaw mocks base method
func (m *MockCommonAPIClient) ContainerInspectWithRaw(ctx context.Context, container string, getSize bool) (types.ContainerJSON, []byte, error) {
	ret := m.ctrl.Call(m, "ContainerInspectWithRaw", ctx, container, getSize)
	ret0, _ := ret[0].(types.ContainerJSON)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ContainerInspectWithRaw indicates an expected call of ContainerInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) ContainerInspectWithRaw(ctx, container, getSize interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerInspectWithRaw), ctx, container, getSize)
}

// ContainerKill mocks base method
func (m *MockCommonAPIClient) ContainerKill(ctx context.Context, container, signal string) error {
	ret := m.ctrl.Call(m, "ContainerKill", ctx, container, signal)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerKill indicates an expected call of ContainerKill
func (mr *MockCommonAPIClientMockRecorder) ContainerKill(ctx, container, signal interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerKill", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerKill), ctx, container, signal)
}

// ContainerList mocks base method
func (m *MockCommonAPIClient) ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error) {
	ret := m.ctrl.Call(m, "ContainerList", ctx, options)
	ret0, _ := ret[0].([]types.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerList indicates an expected call of ContainerList
func (mr *MockCommonAPIClientMockRecorder) ContainerList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerList", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerList), ctx, options)
}

// ContainerLogs mocks base method
func (m *MockCommonAPIClient) ContainerLogs(ctx context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ContainerLogs", ctx, container, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerLogs indicates an expected call of ContainerLogs
func (mr *MockCommonAPIClientMockRecorder) ContainerLogs(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerLogs", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerLogs), ctx, container, options)
}

// ContainerPause mocks base method
func (m *MockCommonAPIClient) ContainerPause(ctx context.Context, container string) error {
	ret := m.ctrl.Call(m, "ContainerPause", ctx, container)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerPause indicates an expected call of ContainerPause
func (mr *MockCommonAPIClientMockRecorder) ContainerPause(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerPause", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerPause), ctx, container)
}

// ContainerRemove mocks base method
func (m *MockCommonAPIClient) ContainerRemove(ctx context.Context, container string, options types.ContainerRemoveOptions) error {
	ret := m.ctrl.Call(m, "ContainerRemove", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRemove indicates an expected call of ContainerRemove
func (mr *MockCommonAPIClientMockRecorder) ContainerRemove(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerRemove), ctx, container, options)
}

// ContainerRename mocks base method
func (m *MockCommonAPIClient) ContainerRename(ctx context.Context, container, newContainerName string) error {
	ret := m.ctrl.Call(m, "ContainerRename", ctx, container, newContainerName)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRename indicates an expected call of ContainerRename
func (mr *MockCommonAPIClientMockRecorder) ContainerRename(ctx, container, newContainerName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRename", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerRename), ctx, container, newContainerName)
}

// ContainerResize mocks base method
func (m *MockCommonAPIClient) ContainerResize(ctx context.Context, container string, options types.ResizeOptions) error {
	ret := m.ctrl.Call(m, "ContainerResize", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerResize indicates an expected call of ContainerResize
func (mr *MockCommonAPIClientMockRecorder) ContainerResize(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerResize", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerResize), ctx, container, options)
}

// ContainerRestart mocks base method
func (m *MockCommonAPIClient) ContainerRestart(ctx context.Context, container string, timeout *time.Duration) error {
	ret := m.ctrl.Call(m, "ContainerRestart", ctx, container, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRestart indicates an expected call of ContainerRestart
func (mr *MockCommonAPIClientMockRecorder) ContainerRestart(ctx, container, timeout interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRestart", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerRestart), ctx, container, timeout)
}

// ContainerStatPath mocks base method
func (m *MockCommonAPIClient) ContainerStatPath(ctx context.Context, container, path string) (types.ContainerPathStat, error) {
	ret := m.ctrl.Call(m, "ContainerStatPath", ctx, container, path)
	ret0, _ := ret[0].(types.ContainerPathStat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStatPath indicates an expected call of ContainerStatPath
func (mr *MockCommonAPIClientMockRecorder) ContainerStatPath(ctx, container, path interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStatPath", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerStatPath), ctx, container, path)
}

// ContainerStats mocks base method
func (m *MockCommonAPIClient) ContainerStats(ctx context.Context, container string, stream bool) (types.ContainerStats, error) {
	ret := m.ctrl.Call(m, "ContainerStats", ctx, container, stream)
	ret0, _ := ret[0].(types.ContainerStats)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStats indicates an expected call of ContainerStats
func (mr *MockCommonAPIClientMockRecorder) ContainerStats(ctx, container, stream interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStats", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerStats), ctx, container, stream)
}

// ContainerStart mocks base method
func (m *MockCommonAPIClient) ContainerStart(ctx context.Context, container string, options types.ContainerStartOptions) error {
	ret := m.ctrl.Call(m, "ContainerStart", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerStart indicates an expected call of ContainerStart
func (mr *MockCommonAPIClientMockRecorder) ContainerStart(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStart", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerStart), ctx, container, options)
}

// ContainerStop mocks base method
func (m *MockCommonAPIClient) ContainerStop(ctx context.Context, container string, timeout *time.Duration) error {
	ret := m.ctrl.Call(m, "ContainerStop", ctx, container, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerStop indicates an expected call of ContainerStop
func (mr *MockCommonAPIClientMockRecorder) ContainerStop(ctx, container, timeout interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStop", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerStop), ctx, container, timeout)
}

// ContainerTop mocks base method
func (m *MockCommonAPIClient) ContainerTop(ctx context.Context, container string, arguments []string) (containerpkg.ContainerTopOKBody, error) {
	ret := m.ctrl.Call(m, "ContainerTop", ctx, container, arguments)
	ret0, _ := ret[0].(containerpkg.ContainerTopOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerTop indicates an expected call of ContainerTop
func (mr *MockCommonAPIClientMockRecorder) ContainerTop(ctx, container, arguments interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerTop", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerTop), ctx, container, arguments)
}

// ContainerUnpause mocks base method
func (m *MockCommonAPIClient) ContainerUnpause(ctx context.Context, container string) error {
	ret := m.ctrl.Call(m, "ContainerUnpause", ctx, container)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerUnpause indicates an expected call of ContainerUnpause
func (mr *MockCommonAPIClientMockRecorder) ContainerUnpause(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerUnpause", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerUnpause), ctx, container)
}

// ContainerUpdate mocks base method
func (m *MockCommonAPIClient) ContainerUpdate(ctx context.Context, container string, updateConfig containerpkg.UpdateConfig) (containerpkg.ContainerUpdateOKBody, error) {
	ret := m.ctrl.Call(m, "ContainerUpdate", ctx, container, updateConfig)
	ret0, _ := ret[0].(containerpkg.ContainerUpdateOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerUpdate indicates an expected call of ContainerUpdate
func (mr *MockCommonAPIClientMockRecorder) ContainerUpdate(ctx, container, updateConfig interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerUpdate", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerUpdate), ctx, container, updateConfig)
}

// ContainerWait mocks base method
func (m *MockCommonAPIClient) ContainerWait(ctx context.Context, container string) (int64, error) {
	ret := m.ctrl.Call(m, "ContainerWait", ctx, container)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerWait indicates an expected call of ContainerWait
func (mr *MockCommonAPIClientMockRecorder) ContainerWait(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerWait", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainerWait), ctx, container)
}

// CopyFromContainer mocks base method
func (m *MockCommonAPIClient) CopyFromContainer(ctx context.Context, container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
	ret := m.ctrl.Call(m, "CopyFromContainer", ctx, container, srcPath)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(types.ContainerPathStat)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CopyFromContainer indicates an expected call of CopyFromContainer
func (mr *MockCommonAPIClientMockRecorder) CopyFromContainer(ctx, container, srcPath interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFromContainer", reflect.TypeOf((*MockCommonAPIClient)(nil).CopyFromContainer), ctx, container, srcPath)
}

// CopyToContainer mocks base method
func (m *MockCommonAPIClient) CopyToContainer(ctx context.Context, container, path string, content io.Reader, options types.CopyToContainerOptions) error {
	ret := m.ctrl.Call(m, "CopyToContainer", ctx, container, path, content, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// CopyToContainer indicates an expected call of CopyToContainer
func (mr *MockCommonAPIClientMockRecorder) CopyToContainer(ctx, container, path, content, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyToContainer", reflect.TypeOf((*MockCommonAPIClient)(nil).CopyToContainer), ctx, container, path, content, options)
}

// ContainersPrune mocks base method
func (m *MockCommonAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (types.ContainersPruneReport, error) {
	ret := m.ctrl.Call(m, "ContainersPrune", ctx, pruneFilters)
	ret0, _ := ret[0].(types.ContainersPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainersPrune indicates an expected call of ContainersPrune
func (mr *MockCommonAPIClientMockRecorder) ContainersPrune(ctx, pruneFilters interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainersPrune", reflect.TypeOf((*MockCommonAPIClient)(nil).ContainersPrune), ctx, pruneFilters)
}

// ImageBuild mocks base method
func (m *MockCommonAPIClient) ImageBuild(ctx context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
	ret := m.ctrl.Call(m, "ImageBuild", ctx, context, options)
	ret0, _ := ret[0].(types.ImageBuildResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageBuild indicates an expected call of ImageBuild
func (mr *MockCommonAPIClientMockRecorder) ImageBuild(ctx, context, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageBuild", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageBuild), ctx, context, options)
}

// ImageCreate mocks base method
func (m *MockCommonAPIClient) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageCreate", ctx, parentReference, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageCreate indicates an expected call of ImageCreate
func (mr *MockCommonAPIClientMockRecorder) ImageCreate(ctx, parentReference, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageCreate), ctx, parentReference, options)
}

// ImageHistory mocks base method
func (m *MockCommonAPIClient) ImageHistory(ctx context.Context, image string) ([]imagepkg.HistoryResponseItem, error) {
	ret := m.ctrl.Call(m, "ImageHistory", ctx, image)
	ret0, _ := ret[0].([]imagepkg.HistoryResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageHistory indicates an expected call of ImageHistory
func (mr *MockCommonAPIClientMockRecorder) ImageHistory(ctx, image interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageHistory", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageHistory), ctx, image)
}

// ImageImport mocks base method
func (m *MockCommonAPIClient) ImageImport(ctx context.Context, source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageImport", ctx, source, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageImport indicates an expected call of ImageImport
func (mr *MockCommonAPIClientMockRecorder) ImageImport(ctx, source, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageImport", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageImport), ctx, source, ref, options)
}

// ImageInspectWithRaw mocks base method
func (m *MockCommonAPIClient) ImageInspectWithRaw(ctx context.Context, image string) (types.ImageInspect, []byte, error) {
	ret := m.ctrl.Call(m, "ImageInspectWithRaw", ctx, image)
	ret0, _ := ret[0].(types.ImageInspect)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ImageInspectWithRaw indicates an expected call of ImageInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) ImageInspectWithRaw(ctx, image interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageInspectWithRaw), ctx, image)
}

// ImageList mocks base method
func (m *MockCommonAPIClient) ImageList(ctx context.Context, options types.ImageListOptions) ([]types.ImageSummary, error) {
	ret := m.ctrl.Call(m, "ImageList", ctx, options)
	ret0, _ := ret[0].([]types.ImageSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageList indicates an expected call of ImageList
func (mr *MockCommonAPIClientMockRecorder) ImageList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageList", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageList), ctx, options)
}

// ImageLoad mocks base method
func (m *MockCommonAPIClient) ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error) {
	ret := m.ctrl.Call(m, "ImageLoad", ctx, input, quiet)
	ret0, _ := ret[0].(types.ImageLoadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageLoad indicates an expected call of ImageLoad
func (mr *MockCommonAPIClientMockRecorder) ImageLoad(ctx, input, quiet interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageLoad", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageLoad), ctx, input, quiet)
}

// ImagePull mocks base method
func (m *MockCommonAPIClient) ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImagePull", ctx, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePull indicates an expected call of ImagePull
func (mr *MockCommonAPIClientMockRecorder) ImagePull(ctx, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePull", reflect.TypeOf((*MockCommonAPIClient)(nil).ImagePull), ctx, ref, options)
}

// ImagePush mocks base method
func (m *MockCommonAPIClient) ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImagePush", ctx, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePush indicates an expected call of ImagePush
func (mr *MockCommonAPIClientMockRecorder) ImagePush(ctx, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePush", reflect.TypeOf((*MockCommonAPIClient)(nil).ImagePush), ctx, ref, options)
}

// ImageRemove mocks base method
func (m *MockCommonAPIClient) ImageRemove(ctx context.Context, image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
	ret := m.ctrl.Call(m, "ImageRemove", ctx, image, options)
	ret0, _ := ret[0].([]types.ImageDeleteResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageRemove indicates an expected call of ImageRemove
func (mr *MockCommonAPIClientMockRecorder) ImageRemove(ctx, image, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageRemove), ctx, image, options)
}

// ImageSearch mocks base method
func (m *MockCommonAPIClient) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) {
	ret := m.ctrl.Call(m, "ImageSearch", ctx, term, options)
	ret0, _ := ret[0].([]registry.SearchResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageSearch indicates an expected call of ImageSearch
func (mr *MockCommonAPIClientMockRecorder) ImageSearch(ctx, term, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageSearch", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageSearch), ctx, term, options)
}

// ImageSave mocks base method
func (m *MockCommonAPIClient) ImageSave(ctx context.Context, images []string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageSave", ctx, images)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageSave indicates an expected call of ImageSave
func (mr *MockCommonAPIClientMockRecorder) ImageSave(ctx, images interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageSave", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageSave), ctx, images)
}

// ImageTag mocks base method
func (m *MockCommonAPIClient) ImageTag(ctx context.Context, image, ref string) error {
	ret := m.ctrl.Call(m, "ImageTag", ctx, image, ref)
	ret0, _ := ret[0].(error)
	return ret0
}

// ImageTag indicates an expected call of ImageTag
func (mr *MockCommonAPIClientMockRecorder) ImageTag(ctx, image, ref interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageTag", reflect.TypeOf((*MockCommonAPIClient)(nil).ImageTag), ctx, image, ref)
}

// ImagesPrune mocks base method
func (m *MockCommonAPIClient) ImagesPrune(ctx context.Context, pruneFilter filters.Args) (types.ImagesPruneReport, error) {
	ret := m.ctrl.Call(m, "ImagesPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.ImagesPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagesPrune indicates an expected call of ImagesPrune
func (mr *MockCommonAPIClientMockRecorder) ImagesPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagesPrune", reflect.TypeOf((*MockCommonAPIClient)(nil).ImagesPrune), ctx, pruneFilter)
}

// NodeInspectWithRaw mocks base method
func (m *MockCommonAPIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
	ret := m.ctrl.Call(m, "NodeInspectWithRaw", ctx, nodeID)
	ret0, _ := ret[0].(swarm.Node)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NodeInspectWithRaw indicates an expected call of NodeInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) NodeInspectWithRaw(ctx, nodeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).NodeInspectWithRaw), ctx, nodeID)
}

// NodeList mocks base method
func (m *MockCommonAPIClient) NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
	ret := m.ctrl.Call(m, "NodeList", ctx, options)
	ret0, _ := ret[0].([]swarm.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NodeList indicates an expected call of NodeList
func (mr *MockCommonAPIClientMockRecorder) NodeList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeList", reflect.TypeOf((*MockCommonAPIClient)(nil).NodeList), ctx, options)
}

// NodeRemove mocks base method
func (m *MockCommonAPIClient) NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error {
	ret := m.ctrl.Call(m, "NodeRemove", ctx, nodeID, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// NodeRemove indicates an expected call of NodeRemove
func (mr *MockCommonAPIClientMockRecorder) NodeRemove(ctx, nodeID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).NodeRemove), ctx, nodeID, options)
}

// NodeUpdate mocks base method
func (m *MockCommonAPIClient) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error {
	ret := m.ctrl.Call(m, "NodeUpdate", ctx, nodeID, version, node)
	ret0, _ := ret[0].(error)
	return ret0
}

// NodeUpdate indicates an expected call of NodeUpdate
func (mr *MockCommonAPIClientMockRecorder) NodeUpdate(ctx, nodeID, version, node interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUpdate", reflect.TypeOf((*MockCommonAPIClient)(nil).NodeUpdate), ctx, nodeID, version, node)
}

// NetworkConnect mocks base method
func (m *MockCommonAPIClient) NetworkConnect(ctx context.Context, networkID, container string, config *network.EndpointSettings) error {
	ret := m.ctrl.Call(m, "NetworkConnect", ctx, networkID, container, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkConnect indicates an expected call of NetworkConnect
func (mr *MockCommonAPIClientMockRecorder) NetworkConnect(ctx, networkID, container, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkConnect", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkConnect), ctx, networkID, container, config)
}

// NetworkCreate mocks base method
func (m *MockCommonAPIClient) NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (types.NetworkCreateResponse, error) {
	ret := m.ctrl.Call(m, "NetworkCreate", ctx, name, options)
	ret0, _ := ret[0].(types.NetworkCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkCreate indicates an expected call of NetworkCreate
func (mr *MockCommonAPIClientMockRecorder) NetworkCreate(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkCreate), ctx, name, options)
}

// NetworkDisconnect mocks base method
func (m *MockCommonAPIClient) NetworkDisconnect(ctx context.Context, networkID, container string, force bool) error {
	ret := m.ctrl.Call(m, "NetworkDisconnect", ctx, networkID, container, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkDisconnect indicates an expected call of NetworkDisconnect
func (mr *MockCommonAPIClientMockRecorder) NetworkDisconnect(ctx, networkID, container, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkDisconnect", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkDisconnect), ctx, networkID, container, force)
}

// NetworkInspect mocks base method
func (m *MockCommonAPIClient) NetworkInspect(ctx context.Context, networkID string, verbose bool) (types.NetworkResource, error) {
	ret := m.ctrl.Call(m, "NetworkInspect", ctx, networkID, verbose)
	ret0, _ := ret[0].(types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkInspect indicates an expected call of NetworkInspect
func (mr *MockCommonAPIClientMockRecorder) NetworkInspect(ctx, networkID, verbose interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInspect", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkInspect), ctx, networkID, verbose)
}

// NetworkInspectWithRaw mocks base method
func (m *MockCommonAPIClient) NetworkInspectWithRaw(ctx context.Context, networkID string, verbose bool) (types.NetworkResource, []byte, error) {
	ret := m.ctrl.Call(m, "NetworkInspectWithRaw", ctx, networkID, verbose)
	ret0, _ := ret[0].(types.NetworkResource)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NetworkInspectWithRaw indicates an expected call of NetworkInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) NetworkInspectWithRaw(ctx, networkID, verbose interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkInspectWithRaw), ctx, networkID, verbose)
}

// NetworkList mocks base method
func (m *MockCommonAPIClient) NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error) {
	ret := m.ctrl.Call(m, "NetworkList", ctx, options)
	ret0, _ := ret[0].([]types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkList indicates an expected call of NetworkList
func (mr *MockCommonAPIClientMockRecorder) NetworkList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkList", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkList), ctx, options)
}

// NetworkRemove mocks base method
func (m *MockCommonAPIClient) NetworkRemove(ctx context.Context, networkID string) error {
	ret := m.ctrl.Call(m, "NetworkRemove", ctx, networkID)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkRemove indicates an expected call of NetworkRemove
func (mr *MockCommonAPIClientMockRecorder) NetworkRemove(ctx, networkID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworkRemove), ctx, networkID)
}

// NetworksPrune mocks base method
func (m *MockCommonAPIClient) NetworksPrune(ctx context.Context, pruneFilter filters.Args) (types.NetworksPruneReport, error) {
	ret := m.ctrl.Call(m, "NetworksPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.NetworksPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworksPrune indicates an expected call of NetworksPrune
func (mr *MockCommonAPIClientMockRecorder) NetworksPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworksPrune", reflect.TypeOf((*MockCommonAPIClient)(nil).NetworksPrune), ctx, pruneFilter)
}

// PluginList mocks base method
func (m *MockCommonAPIClient) PluginList(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error) {
	ret := m.ctrl.Call(m, "PluginList", ctx, filter)
	ret0, _ := ret[0].(types.PluginsListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginList indicates an expected call of PluginList
func (mr *MockCommonAPIClientMockRecorder) PluginList(ctx, filter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginList", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginList), ctx, filter)
}

// PluginRemove mocks base method
func (m *MockCommonAPIClient) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error {
	ret := m.ctrl.Call(m, "PluginRemove", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginRemove indicates an expected call of PluginRemove
func (mr *MockCommonAPIClientMockRecorder) PluginRemove(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginRemove), ctx, name, options)
}

// PluginEnable mocks base method
func (m *MockCommonAPIClient) PluginEnable(ctx context.Context, name string, options types.PluginEnableOptions) error {
	ret := m.ctrl.Call(m, "PluginEnable", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginEnable indicates an expected call of PluginEnable
func (mr *MockCommonAPIClientMockRecorder) PluginEnable(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginEnable", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginEnable), ctx, name, options)
}

// PluginDisable mocks base method
func (m *MockCommonAPIClient) PluginDisable(ctx context.Context, name string, options types.PluginDisableOptions) error {
	ret := m.ctrl.Call(m, "PluginDisable", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginDisable indicates an expected call of PluginDisable
func (mr *MockCommonAPIClientMockRecorder) PluginDisable(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginDisable", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginDisable), ctx, name, options)
}

// PluginInstall mocks base method
func (m *MockCommonAPIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginInstall", ctx, name, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginInstall indicates an expected call of PluginInstall
func (mr *MockCommonAPIClientMockRecorder) PluginInstall(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginInstall", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginInstall), ctx, name, options)
}

// PluginUpgrade mocks base method
func (m *MockCommonAPIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginUpgrade", ctx, name, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginUpgrade indicates an expected call of PluginUpgrade
func (mr *MockCommonAPIClientMockRecorder) PluginUpgrade(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginUpgrade", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginUpgrade), ctx, name, options)
}

// PluginPush mocks base method
func (m *MockCommonAPIClient) PluginPush(ctx context.Context, name, registryAuth string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginPush", ctx, name, registryAuth)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginPush indicates an expected call of PluginPush
func (mr *MockCommonAPIClientMockRecorder) PluginPush(ctx, name, registryAuth interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginPush", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginPush), ctx, name, registryAuth)
}

// PluginSet mocks base method
func (m *MockCommonAPIClient) PluginSet(ctx context.Context, name string, args []string) error {
	ret := m.ctrl.Call(m, "PluginSet", ctx, name, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginSet indicates an expected call of PluginSet
func (mr *MockCommonAPIClientMockRecorder) PluginSet(ctx, name, args interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginSet", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginSet), ctx, name, args)
}

// PluginInspectWithRaw mocks base method
func (m *MockCommonAPIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
	ret := m.ctrl.Call(m, "PluginInspectWithRaw", ctx, name)
	ret0, _ := ret[0].(*types.Plugin)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PluginInspectWithRaw indicates an expected call of PluginInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) PluginInspectWithRaw(ctx, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginInspectWithRaw), ctx, name)
}

// PluginCreate mocks base method
func (m *MockCommonAPIClient) PluginCreate(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions) error {
	ret := m.ctrl.Call(m, "PluginCreate", ctx, createContext, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginCreate indicates an expected call of PluginCreate
func (mr *MockCommonAPIClientMockRecorder) PluginCreate(ctx, createContext, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).PluginCreate), ctx, createContext, options)
}

// ServiceCreate mocks base method
func (m *MockCommonAPIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error) {
	ret := m.ctrl.Call(m, "ServiceCreate", ctx, service, options)
	ret0, _ := ret[0].(types.ServiceCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceCreate indicates an expected call of ServiceCreate
func (mr *MockCommonAPIClientMockRecorder) ServiceCreate(ctx, service, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceCreate), ctx, service, options)
}

// ServiceInspectWithRaw mocks base method
func (m *MockCommonAPIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string, options types.ServiceInspectOptions) (swarm.Service, []byte, error) {
	ret := m.ctrl.Call(m, "ServiceInspectWithRaw", ctx, serviceID, options)
	ret0, _ := ret[0].(swarm.Service)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ServiceInspectWithRaw indicates an expected call of ServiceInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) ServiceInspectWithRaw(ctx, serviceID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceInspectWithRaw), ctx, serviceID, options)
}

// ServiceList mocks base method
func (m *MockCommonAPIClient) ServiceList(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
	ret := m.ctrl.Call(m, "ServiceList", ctx, options)
	ret0, _ := ret[0].([]swarm.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceList indicates an expected call of ServiceList
func (mr *MockCommonAPIClientMockRecorder) ServiceList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceList", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceList), ctx, options)
}

// ServiceRemove mocks base method
func (m *MockCommonAPIClient) ServiceRemove(ctx context.Context, serviceID string) error {
	ret := m.ctrl.Call(m, "ServiceRemove", ctx, serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ServiceRemove indicates an expected call of ServiceRemove
func (mr *MockCommonAPIClientMockRecorder) ServiceRemove(ctx, serviceID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceRemove), ctx, serviceID)
}

// ServiceUpdate mocks base method
func (m *MockCommonAPIClient) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) (types.ServiceUpdateResponse, error) {
	ret := m.ctrl.Call(m, "ServiceUpdate", ctx, serviceID, version, service, options)
	ret0, _ := ret[0].(types.ServiceUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceUpdate indicates an expected call of ServiceUpdate
func (mr *MockCommonAPIClientMockRecorder) ServiceUpdate(ctx, serviceID, version, service, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceUpdate", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceUpdate), ctx, serviceID, version, service, options)
}

// ServiceLogs mocks base method
func (m *MockCommonAPIClient) ServiceLogs(ctx context.Context, serviceID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ServiceLogs", ctx, serviceID, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceLogs indicates an expected call of ServiceLogs
func (mr *MockCommonAPIClientMockRecorder) ServiceLogs(ctx, serviceID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceLogs", reflect.TypeOf((*MockCommonAPIClient)(nil).ServiceLogs), ctx, serviceID, options)
}

// TaskLogs mocks base method
func (m *MockCommonAPIClient) TaskLogs(ctx context.Context, taskID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "TaskLogs", ctx, taskID, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskLogs indicates an expected call of TaskLogs
func (mr *MockCommonAPIClientMockRecorder) TaskLogs(ctx, taskID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskLogs", reflect.TypeOf((*MockCommonAPIClient)(nil).TaskLogs), ctx, taskID, options)
}

// TaskInspectWithRaw mocks base method
func (m *MockCommonAPIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
	ret := m.ctrl.Call(m, "TaskInspectWithRaw", ctx, taskID)
	ret0, _ := ret[0].(swarm.Task)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// TaskInspectWithRaw indicates an expected call of TaskInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) TaskInspectWithRaw(ctx, taskID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).TaskInspectWithRaw), ctx, taskID)
}

// TaskList mocks base method
func (m *MockCommonAPIClient) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
	ret := m.ctrl.Call(m, "TaskList", ctx, options)
	ret0, _ := ret[0].([]swarm.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskList indicates an expected call of TaskList
func (mr *MockCommonAPIClientMockRecorder) TaskList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskList", reflect.TypeOf((*MockCommonAPIClient)(nil).TaskList), ctx, options)
}

// SwarmInit mocks base method
func (m *MockCommonAPIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
	ret := m.ctrl.Call(m, "SwarmInit", ctx, req)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmInit indicates an expected call of SwarmInit
func (mr *MockCommonAPIClientMockRecorder) SwarmInit(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmInit", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmInit), ctx, req)
}

// SwarmJoin mocks base method
func (m *MockCommonAPIClient) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error {
	ret := m.ctrl.Call(m, "SwarmJoin", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmJoin indicates an expected call of SwarmJoin
func (mr *MockCommonAPIClientMockRecorder) SwarmJoin(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmJoin", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmJoin), ctx, req)
}

// SwarmGetUnlockKey mocks base method
func (m *MockCommonAPIClient) SwarmGetUnlockKey(ctx context.Context) (types.SwarmUnlockKeyResponse, error) {
	ret := m.ctrl.Call(m, "SwarmGetUnlockKey", ctx)
	ret0, _ := ret[0].(types.SwarmUnlockKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmGetUnlockKey indicates an expected call of SwarmGetUnlockKey
func (mr *MockCommonAPIClientMockRecorder) SwarmGetUnlockKey(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmGetUnlockKey", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmGetUnlockKey), ctx)
}

// SwarmUnlock mocks base method
func (m *MockCommonAPIClient) SwarmUnlock(ctx context.Context, req swarm.UnlockRequest) error {
	ret := m.ctrl.Call(m, "SwarmUnlock", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmUnlock indicates an expected call of SwarmUnlock
func (mr *MockCommonAPIClientMockRecorder) SwarmUnlock(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmUnlock", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmUnlock), ctx, req)
}

// SwarmLeave mocks base method
func (m *MockCommonAPIClient) SwarmLeave(ctx context.Context, force bool) error {
	ret := m.ctrl.Call(m, "SwarmLeave", ctx, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmLeave indicates an expected call of SwarmLeave
func (mr *MockCommonAPIClientMockRecorder) SwarmLeave(ctx, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmLeave", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmLeave), ctx, force)
}

// SwarmInspect mocks base method
func (m *MockCommonAPIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
	ret := m.ctrl.Call(m, "SwarmInspect", ctx)
	ret0, _ := ret[0].(swarm.Swarm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmInspect indicates an expected call of SwarmInspect
func (mr *MockCommonAPIClientMockRecorder) SwarmInspect(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmInspect", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmInspect), ctx)
}

// SwarmUpdate mocks base method
func (m *MockCommonAPIClient) SwarmUpdate(ctx context.Context, version swarm.Version, swarm swarm.Spec, flags swarm.UpdateFlags) error {
	ret := m.ctrl.Call(m, "SwarmUpdate", ctx, version, swarm, flags)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmUpdate indicates an expected call of SwarmUpdate
func (mr *MockCommonAPIClientMockRecorder) SwarmUpdate(ctx, version, swarm, flags interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmUpdate", reflect.TypeOf((*MockCommonAPIClient)(nil).SwarmUpdate), ctx, version, swarm, flags)
}

// SecretList mocks base method
func (m *MockCommonAPIClient) SecretList(ctx context.Context, options types.SecretListOptions) ([]swarm.Secret, error) {
	ret := m.ctrl.Call(m, "SecretList", ctx, options)
	ret0, _ := ret[0].([]swarm.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SecretList indicates an expected call of SecretList
func (mr *MockCommonAPIClientMockRecorder) SecretList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretList", reflect.TypeOf((*MockCommonAPIClient)(nil).SecretList), ctx, options)
}

// SecretCreate mocks base method
func (m *MockCommonAPIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (types.SecretCreateResponse, error) {
	ret := m.ctrl.Call(m, "SecretCreate", ctx, secret)
	ret0, _ := ret[0].(types.SecretCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SecretCreate indicates an expected call of SecretCreate
func (mr *MockCommonAPIClientMockRecorder) SecretCreate(ctx, secret interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).SecretCreate), ctx, secret)
}

// SecretRemove mocks base method
func (m *MockCommonAPIClient) SecretRemove(ctx context.Context, id string) error {
	ret := m.ctrl.Call(m, "SecretRemove", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// SecretRemove indicates an expected call of SecretRemove
func (mr *MockCommonAPIClientMockRecorder) SecretRemove(ctx, id interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).SecretRemove), ctx, id)
}

// SecretInspectWithRaw mocks base method
func (m *MockCommonAPIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error) {
	ret := m.ctrl.Call(m, "SecretInspectWithRaw", ctx, name)
	ret0, _ := ret[0].(swarm.Secret)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SecretInspectWithRaw indicates an expected call of SecretInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) SecretInspectWithRaw(ctx, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).SecretInspectWithRaw), ctx, name)
}

// SecretUpdate mocks base method
func (m *MockCommonAPIClient) SecretUpdate(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error {
	ret := m.ctrl.Call(m, "SecretUpdate", ctx, id, version, secret)
	ret0, _ := ret[0].(error)
	return ret0
}

// SecretUpdate indicates an expected call of SecretUpdate
func (mr *MockCommonAPIClientMockRecorder) SecretUpdate(ctx, id, version, secret interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretUpdate", reflect.TypeOf((*MockCommonAPIClient)(nil).SecretUpdate), ctx, id, version, secret)
}

// Events mocks base method
func (m *MockCommonAPIClient) Events(ctx context.Context, options types.EventsOptions) (<-chan events.Message, <-chan error) {
	ret := m.ctrl.Call(m, "Events", ctx, options)
	ret0, _ := ret[0].(<-chan events.Message)
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// Events indicates an expected call of Events
func (mr *MockCommonAPIClientMockRecorder) Events(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Events", reflect.TypeOf((*MockCommonAPIClient)(nil).Events), ctx, options)
}

// Info mocks base method
func (m *MockCommonAPIClient) Info(ctx context.Context) (types.Info, error) {
	ret := m.ctrl.Call(m, "Info", ctx)
	ret0, _ := ret[0].(types.Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Info indicates an expected call of Info
func (mr *MockCommonAPIClientMockRecorder) Info(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockCommonAPIClient)(nil).Info), ctx)
}

// RegistryLogin mocks base method
func (m *MockCommonAPIClient) RegistryLogin(ctx context.Context, auth types.AuthConfig) (registry.AuthenticateOKBody, error) {
	ret := m.ctrl.Call(m, "RegistryLogin", ctx, auth)
	ret0, _ := ret[0].(registry.AuthenticateOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegistryLogin indicates an expected call of RegistryLogin
func (mr *MockCommonAPIClientMockRecorder) RegistryLogin(ctx, auth interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegistryLogin", reflect.TypeOf((*MockCommonAPIClient)(nil).RegistryLogin), ctx, auth)
}

// DiskUsage mocks base method
func (m *MockCommonAPIClient) DiskUsage(ctx context.Context) (types.DiskUsage, error) {
	ret := m.ctrl.Call(m, "DiskUsage", ctx)
	ret0, _ := ret[0].(types.DiskUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiskUsage indicates an expected call of DiskUsage
func (mr *MockCommonAPIClientMockRecorder) DiskUsage(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiskUsage", reflect.TypeOf((*MockCommonAPIClient)(nil).DiskUsage), ctx)
}

// Ping mocks base method
func (m *MockCommonAPIClient) Ping(ctx context.Context) (types.Ping, error) {
	ret := m.ctrl.Call(m, "Ping", ctx)
	ret0, _ := ret[0].(types.Ping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ping indicates an expected call of Ping
func (mr *MockCommonAPIClientMockRecorder) Ping(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCommonAPIClient)(nil).Ping), ctx)
}

// VolumeCreate mocks base method
func (m *MockCommonAPIClient) VolumeCreate(ctx context.Context, options volume.VolumesCreateBody) (types.Volume, error) {
	ret := m.ctrl.Call(m, "VolumeCreate", ctx, options)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeCreate indicates an expected call of VolumeCreate
func (mr *MockCommonAPIClientMockRecorder) VolumeCreate(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeCreate", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumeCreate), ctx, options)
}

// VolumeInspect mocks base method
func (m *MockCommonAPIClient) VolumeInspect(ctx context.Context, volumeID string) (types.Volume, error) {
	ret := m.ctrl.Call(m, "VolumeInspect", ctx, volumeID)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeInspect indicates an expected call of VolumeInspect
func (mr *MockCommonAPIClientMockRecorder) VolumeInspect(ctx, volumeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeInspect", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumeInspect), ctx, volumeID)
}

// VolumeInspectWithRaw mocks base method
func (m *MockCommonAPIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (types.Volume, []byte, error) {
	ret := m.ctrl.Call(m, "VolumeInspectWithRaw", ctx, volumeID)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// VolumeInspectWithRaw indicates an expected call of VolumeInspectWithRaw
func (mr *MockCommonAPIClientMockRecorder) VolumeInspectWithRaw(ctx, volumeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeInspectWithRaw", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumeInspectWithRaw), ctx, volumeID)
}

// VolumeList mocks base method
func (m *MockCommonAPIClient) VolumeList(ctx context.Context, filter filters.Args) (volume.VolumesListOKBody, error) {
	ret := m.ctrl.Call(m, "VolumeList", ctx, filter)
	ret0, _ := ret[0].(volume.VolumesListOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeList indicates an expected call of VolumeList
func (mr *MockCommonAPIClientMockRecorder) VolumeList(ctx, filter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeList", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumeList), ctx, filter)
}

// VolumeRemove mocks base method
func (m *MockCommonAPIClient) VolumeRemove(ctx context.Context, volumeID string, force bool) error {
	ret := m.ctrl.Call(m, "VolumeRemove", ctx, volumeID, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// VolumeRemove indicates an expected call of VolumeRemove
func (mr *MockCommonAPIClientMockRecorder) VolumeRemove(ctx, volumeID, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeRemove", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumeRemove), ctx, volumeID, force)
}

// VolumesPrune mocks base method
func (m *MockCommonAPIClient) VolumesPrune(ctx context.Context, pruneFilter filters.Args) (types.VolumesPruneReport, error) {
	ret := m.ctrl.Call(m, "VolumesPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.VolumesPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumesPrune indicates an expected call of VolumesPrune
func (mr *MockCommonAPIClientMockRecorder) VolumesPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumesPrune", reflect.TypeOf((*MockCommonAPIClient)(nil).VolumesPrune), ctx, pruneFilter)
}

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

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

// ServerVersion mocks base method
func (m *MockCommonAPIClient) ServerVersion(ctx context.Context) (types.Version, error) {
	ret := m.ctrl.Call(m, "ServerVersion", ctx)
	ret0, _ := ret[0].(types.Version)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServerVersion indicates an expected call of ServerVersion
func (mr *MockCommonAPIClientMockRecorder) ServerVersion(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerVersion", reflect.TypeOf((*MockCommonAPIClient)(nil).ServerVersion), ctx)
}

// UpdateClientVersion mocks base method
func (m *MockCommonAPIClient) UpdateClientVersion(v string) {
	m.ctrl.Call(m, "UpdateClientVersion", v)
}

// UpdateClientVersion indicates an expected call of UpdateClientVersion
func (mr *MockCommonAPIClientMockRecorder) UpdateClientVersion(v interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClientVersion", reflect.TypeOf((*MockCommonAPIClient)(nil).UpdateClientVersion), v)
}

// MockContainerAPIClient is a mock of ContainerAPIClient interface
type MockContainerAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockContainerAPIClientMockRecorder
}

// MockContainerAPIClientMockRecorder is the mock recorder for MockContainerAPIClient
type MockContainerAPIClientMockRecorder struct {
	mock *MockContainerAPIClient
}

// NewMockContainerAPIClient creates a new mock instance
func NewMockContainerAPIClient(ctrl *gomock.Controller) *MockContainerAPIClient {
	mock := &MockContainerAPIClient{ctrl: ctrl}
	mock.recorder = &MockContainerAPIClientMockRecorder{mock}
	return mock
}

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

// ContainerAttach mocks base method
func (m *MockContainerAPIClient) ContainerAttach(ctx context.Context, container string, options types.ContainerAttachOptions) (types.HijackedResponse, error) {
	ret := m.ctrl.Call(m, "ContainerAttach", ctx, container, options)
	ret0, _ := ret[0].(types.HijackedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerAttach indicates an expected call of ContainerAttach
func (mr *MockContainerAPIClientMockRecorder) ContainerAttach(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerAttach", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerAttach), ctx, container, options)
}

// ContainerCommit mocks base method
func (m *MockContainerAPIClient) ContainerCommit(ctx context.Context, container string, options types.ContainerCommitOptions) (types.IDResponse, error) {
	ret := m.ctrl.Call(m, "ContainerCommit", ctx, container, options)
	ret0, _ := ret[0].(types.IDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerCommit indicates an expected call of ContainerCommit
func (mr *MockContainerAPIClientMockRecorder) ContainerCommit(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerCommit", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerCommit), ctx, container, options)
}

// ContainerCreate mocks base method
func (m *MockContainerAPIClient) ContainerCreate(ctx context.Context, config *containerpkg.Config, hostConfig *containerpkg.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (containerpkg.ContainerCreateCreatedBody, error) {
	ret := m.ctrl.Call(m, "ContainerCreate", ctx, config, hostConfig, networkingConfig, containerName)
	ret0, _ := ret[0].(containerpkg.ContainerCreateCreatedBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerCreate indicates an expected call of ContainerCreate
func (mr *MockContainerAPIClientMockRecorder) ContainerCreate(ctx, config, hostConfig, networkingConfig, containerName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerCreate", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerCreate), ctx, config, hostConfig, networkingConfig, containerName)
}

// ContainerDiff mocks base method
func (m *MockContainerAPIClient) ContainerDiff(ctx context.Context, container string) ([]containerpkg.ContainerChangeResponseItem, error) {
	ret := m.ctrl.Call(m, "ContainerDiff", ctx, container)
	ret0, _ := ret[0].([]containerpkg.ContainerChangeResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerDiff indicates an expected call of ContainerDiff
func (mr *MockContainerAPIClientMockRecorder) ContainerDiff(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerDiff", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerDiff), ctx, container)
}

// ContainerExecAttach mocks base method
func (m *MockContainerAPIClient) ContainerExecAttach(ctx context.Context, execID string, config types.ExecConfig) (types.HijackedResponse, error) {
	ret := m.ctrl.Call(m, "ContainerExecAttach", ctx, execID, config)
	ret0, _ := ret[0].(types.HijackedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecAttach indicates an expected call of ContainerExecAttach
func (mr *MockContainerAPIClientMockRecorder) ContainerExecAttach(ctx, execID, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecAttach", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExecAttach), ctx, execID, config)
}

// ContainerExecCreate mocks base method
func (m *MockContainerAPIClient) ContainerExecCreate(ctx context.Context, container string, config types.ExecConfig) (types.IDResponse, error) {
	ret := m.ctrl.Call(m, "ContainerExecCreate", ctx, container, config)
	ret0, _ := ret[0].(types.IDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecCreate indicates an expected call of ContainerExecCreate
func (mr *MockContainerAPIClientMockRecorder) ContainerExecCreate(ctx, container, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecCreate", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExecCreate), ctx, container, config)
}

// ContainerExecInspect mocks base method
func (m *MockContainerAPIClient) ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error) {
	ret := m.ctrl.Call(m, "ContainerExecInspect", ctx, execID)
	ret0, _ := ret[0].(types.ContainerExecInspect)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExecInspect indicates an expected call of ContainerExecInspect
func (mr *MockContainerAPIClientMockRecorder) ContainerExecInspect(ctx, execID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecInspect", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExecInspect), ctx, execID)
}

// ContainerExecResize mocks base method
func (m *MockContainerAPIClient) ContainerExecResize(ctx context.Context, execID string, options types.ResizeOptions) error {
	ret := m.ctrl.Call(m, "ContainerExecResize", ctx, execID, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerExecResize indicates an expected call of ContainerExecResize
func (mr *MockContainerAPIClientMockRecorder) ContainerExecResize(ctx, execID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecResize", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExecResize), ctx, execID, options)
}

// ContainerExecStart mocks base method
func (m *MockContainerAPIClient) ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error {
	ret := m.ctrl.Call(m, "ContainerExecStart", ctx, execID, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerExecStart indicates an expected call of ContainerExecStart
func (mr *MockContainerAPIClientMockRecorder) ContainerExecStart(ctx, execID, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExecStart", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExecStart), ctx, execID, config)
}

// ContainerExport mocks base method
func (m *MockContainerAPIClient) ContainerExport(ctx context.Context, container string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ContainerExport", ctx, container)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerExport indicates an expected call of ContainerExport
func (mr *MockContainerAPIClientMockRecorder) ContainerExport(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerExport", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerExport), ctx, container)
}

// ContainerInspect mocks base method
func (m *MockContainerAPIClient) ContainerInspect(ctx context.Context, container string) (types.ContainerJSON, error) {
	ret := m.ctrl.Call(m, "ContainerInspect", ctx, container)
	ret0, _ := ret[0].(types.ContainerJSON)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerInspect indicates an expected call of ContainerInspect
func (mr *MockContainerAPIClientMockRecorder) ContainerInspect(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInspect", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerInspect), ctx, container)
}

// ContainerInspectWithRaw mocks base method
func (m *MockContainerAPIClient) ContainerInspectWithRaw(ctx context.Context, container string, getSize bool) (types.ContainerJSON, []byte, error) {
	ret := m.ctrl.Call(m, "ContainerInspectWithRaw", ctx, container, getSize)
	ret0, _ := ret[0].(types.ContainerJSON)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ContainerInspectWithRaw indicates an expected call of ContainerInspectWithRaw
func (mr *MockContainerAPIClientMockRecorder) ContainerInspectWithRaw(ctx, container, getSize interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInspectWithRaw", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerInspectWithRaw), ctx, container, getSize)
}

// ContainerKill mocks base method
func (m *MockContainerAPIClient) ContainerKill(ctx context.Context, container, signal string) error {
	ret := m.ctrl.Call(m, "ContainerKill", ctx, container, signal)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerKill indicates an expected call of ContainerKill
func (mr *MockContainerAPIClientMockRecorder) ContainerKill(ctx, container, signal interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerKill", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerKill), ctx, container, signal)
}

// ContainerList mocks base method
func (m *MockContainerAPIClient) ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error) {
	ret := m.ctrl.Call(m, "ContainerList", ctx, options)
	ret0, _ := ret[0].([]types.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerList indicates an expected call of ContainerList
func (mr *MockContainerAPIClientMockRecorder) ContainerList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerList", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerList), ctx, options)
}

// ContainerLogs mocks base method
func (m *MockContainerAPIClient) ContainerLogs(ctx context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ContainerLogs", ctx, container, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerLogs indicates an expected call of ContainerLogs
func (mr *MockContainerAPIClientMockRecorder) ContainerLogs(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerLogs", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerLogs), ctx, container, options)
}

// ContainerPause mocks base method
func (m *MockContainerAPIClient) ContainerPause(ctx context.Context, container string) error {
	ret := m.ctrl.Call(m, "ContainerPause", ctx, container)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerPause indicates an expected call of ContainerPause
func (mr *MockContainerAPIClientMockRecorder) ContainerPause(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerPause", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerPause), ctx, container)
}

// ContainerRemove mocks base method
func (m *MockContainerAPIClient) ContainerRemove(ctx context.Context, container string, options types.ContainerRemoveOptions) error {
	ret := m.ctrl.Call(m, "ContainerRemove", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRemove indicates an expected call of ContainerRemove
func (mr *MockContainerAPIClientMockRecorder) ContainerRemove(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRemove", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerRemove), ctx, container, options)
}

// ContainerRename mocks base method
func (m *MockContainerAPIClient) ContainerRename(ctx context.Context, container, newContainerName string) error {
	ret := m.ctrl.Call(m, "ContainerRename", ctx, container, newContainerName)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRename indicates an expected call of ContainerRename
func (mr *MockContainerAPIClientMockRecorder) ContainerRename(ctx, container, newContainerName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRename", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerRename), ctx, container, newContainerName)
}

// ContainerResize mocks base method
func (m *MockContainerAPIClient) ContainerResize(ctx context.Context, container string, options types.ResizeOptions) error {
	ret := m.ctrl.Call(m, "ContainerResize", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerResize indicates an expected call of ContainerResize
func (mr *MockContainerAPIClientMockRecorder) ContainerResize(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerResize", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerResize), ctx, container, options)
}

// ContainerRestart mocks base method
func (m *MockContainerAPIClient) ContainerRestart(ctx context.Context, container string, timeout *time.Duration) error {
	ret := m.ctrl.Call(m, "ContainerRestart", ctx, container, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerRestart indicates an expected call of ContainerRestart
func (mr *MockContainerAPIClientMockRecorder) ContainerRestart(ctx, container, timeout interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRestart", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerRestart), ctx, container, timeout)
}

// ContainerStatPath mocks base method
func (m *MockContainerAPIClient) ContainerStatPath(ctx context.Context, container, path string) (types.ContainerPathStat, error) {
	ret := m.ctrl.Call(m, "ContainerStatPath", ctx, container, path)
	ret0, _ := ret[0].(types.ContainerPathStat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStatPath indicates an expected call of ContainerStatPath
func (mr *MockContainerAPIClientMockRecorder) ContainerStatPath(ctx, container, path interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStatPath", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerStatPath), ctx, container, path)
}

// ContainerStats mocks base method
func (m *MockContainerAPIClient) ContainerStats(ctx context.Context, container string, stream bool) (types.ContainerStats, error) {
	ret := m.ctrl.Call(m, "ContainerStats", ctx, container, stream)
	ret0, _ := ret[0].(types.ContainerStats)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStats indicates an expected call of ContainerStats
func (mr *MockContainerAPIClientMockRecorder) ContainerStats(ctx, container, stream interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStats", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerStats), ctx, container, stream)
}

// ContainerStart mocks base method
func (m *MockContainerAPIClient) ContainerStart(ctx context.Context, container string, options types.ContainerStartOptions) error {
	ret := m.ctrl.Call(m, "ContainerStart", ctx, container, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerStart indicates an expected call of ContainerStart
func (mr *MockContainerAPIClientMockRecorder) ContainerStart(ctx, container, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStart", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerStart), ctx, container, options)
}

// ContainerStop mocks base method
func (m *MockContainerAPIClient) ContainerStop(ctx context.Context, container string, timeout *time.Duration) error {
	ret := m.ctrl.Call(m, "ContainerStop", ctx, container, timeout)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerStop indicates an expected call of ContainerStop
func (mr *MockContainerAPIClientMockRecorder) ContainerStop(ctx, container, timeout interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStop", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerStop), ctx, container, timeout)
}

// ContainerTop mocks base method
func (m *MockContainerAPIClient) ContainerTop(ctx context.Context, container string, arguments []string) (containerpkg.ContainerTopOKBody, error) {
	ret := m.ctrl.Call(m, "ContainerTop", ctx, container, arguments)
	ret0, _ := ret[0].(containerpkg.ContainerTopOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerTop indicates an expected call of ContainerTop
func (mr *MockContainerAPIClientMockRecorder) ContainerTop(ctx, container, arguments interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerTop", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerTop), ctx, container, arguments)
}

// ContainerUnpause mocks base method
func (m *MockContainerAPIClient) ContainerUnpause(ctx context.Context, container string) error {
	ret := m.ctrl.Call(m, "ContainerUnpause", ctx, container)
	ret0, _ := ret[0].(error)
	return ret0
}

// ContainerUnpause indicates an expected call of ContainerUnpause
func (mr *MockContainerAPIClientMockRecorder) ContainerUnpause(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerUnpause", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerUnpause), ctx, container)
}

// ContainerUpdate mocks base method
func (m *MockContainerAPIClient) ContainerUpdate(ctx context.Context, container string, updateConfig containerpkg.UpdateConfig) (containerpkg.ContainerUpdateOKBody, error) {
	ret := m.ctrl.Call(m, "ContainerUpdate", ctx, container, updateConfig)
	ret0, _ := ret[0].(containerpkg.ContainerUpdateOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerUpdate indicates an expected call of ContainerUpdate
func (mr *MockContainerAPIClientMockRecorder) ContainerUpdate(ctx, container, updateConfig interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerUpdate", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerUpdate), ctx, container, updateConfig)
}

// ContainerWait mocks base method
func (m *MockContainerAPIClient) ContainerWait(ctx context.Context, container string) (int64, error) {
	ret := m.ctrl.Call(m, "ContainerWait", ctx, container)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerWait indicates an expected call of ContainerWait
func (mr *MockContainerAPIClientMockRecorder) ContainerWait(ctx, container interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerWait", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainerWait), ctx, container)
}

// CopyFromContainer mocks base method
func (m *MockContainerAPIClient) CopyFromContainer(ctx context.Context, container, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
	ret := m.ctrl.Call(m, "CopyFromContainer", ctx, container, srcPath)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(types.ContainerPathStat)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CopyFromContainer indicates an expected call of CopyFromContainer
func (mr *MockContainerAPIClientMockRecorder) CopyFromContainer(ctx, container, srcPath interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFromContainer", reflect.TypeOf((*MockContainerAPIClient)(nil).CopyFromContainer), ctx, container, srcPath)
}

// CopyToContainer mocks base method
func (m *MockContainerAPIClient) CopyToContainer(ctx context.Context, container, path string, content io.Reader, options types.CopyToContainerOptions) error {
	ret := m.ctrl.Call(m, "CopyToContainer", ctx, container, path, content, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// CopyToContainer indicates an expected call of CopyToContainer
func (mr *MockContainerAPIClientMockRecorder) CopyToContainer(ctx, container, path, content, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyToContainer", reflect.TypeOf((*MockContainerAPIClient)(nil).CopyToContainer), ctx, container, path, content, options)
}

// ContainersPrune mocks base method
func (m *MockContainerAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (types.ContainersPruneReport, error) {
	ret := m.ctrl.Call(m, "ContainersPrune", ctx, pruneFilters)
	ret0, _ := ret[0].(types.ContainersPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainersPrune indicates an expected call of ContainersPrune
func (mr *MockContainerAPIClientMockRecorder) ContainersPrune(ctx, pruneFilters interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainersPrune", reflect.TypeOf((*MockContainerAPIClient)(nil).ContainersPrune), ctx, pruneFilters)
}

// MockImageAPIClient is a mock of ImageAPIClient interface
type MockImageAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockImageAPIClientMockRecorder
}

// MockImageAPIClientMockRecorder is the mock recorder for MockImageAPIClient
type MockImageAPIClientMockRecorder struct {
	mock *MockImageAPIClient
}

// NewMockImageAPIClient creates a new mock instance
func NewMockImageAPIClient(ctrl *gomock.Controller) *MockImageAPIClient {
	mock := &MockImageAPIClient{ctrl: ctrl}
	mock.recorder = &MockImageAPIClientMockRecorder{mock}
	return mock
}

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

// ImageBuild mocks base method
func (m *MockImageAPIClient) ImageBuild(ctx context.Context, context io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
	ret := m.ctrl.Call(m, "ImageBuild", ctx, context, options)
	ret0, _ := ret[0].(types.ImageBuildResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageBuild indicates an expected call of ImageBuild
func (mr *MockImageAPIClientMockRecorder) ImageBuild(ctx, context, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageBuild", reflect.TypeOf((*MockImageAPIClient)(nil).ImageBuild), ctx, context, options)
}

// ImageCreate mocks base method
func (m *MockImageAPIClient) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageCreate", ctx, parentReference, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageCreate indicates an expected call of ImageCreate
func (mr *MockImageAPIClientMockRecorder) ImageCreate(ctx, parentReference, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageCreate", reflect.TypeOf((*MockImageAPIClient)(nil).ImageCreate), ctx, parentReference, options)
}

// ImageHistory mocks base method
func (m *MockImageAPIClient) ImageHistory(ctx context.Context, image string) ([]imagepkg.HistoryResponseItem, error) {
	ret := m.ctrl.Call(m, "ImageHistory", ctx, image)
	ret0, _ := ret[0].([]imagepkg.HistoryResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageHistory indicates an expected call of ImageHistory
func (mr *MockImageAPIClientMockRecorder) ImageHistory(ctx, image interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageHistory", reflect.TypeOf((*MockImageAPIClient)(nil).ImageHistory), ctx, image)
}

// ImageImport mocks base method
func (m *MockImageAPIClient) ImageImport(ctx context.Context, source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageImport", ctx, source, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageImport indicates an expected call of ImageImport
func (mr *MockImageAPIClientMockRecorder) ImageImport(ctx, source, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageImport", reflect.TypeOf((*MockImageAPIClient)(nil).ImageImport), ctx, source, ref, options)
}

// ImageInspectWithRaw mocks base method
func (m *MockImageAPIClient) ImageInspectWithRaw(ctx context.Context, image string) (types.ImageInspect, []byte, error) {
	ret := m.ctrl.Call(m, "ImageInspectWithRaw", ctx, image)
	ret0, _ := ret[0].(types.ImageInspect)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ImageInspectWithRaw indicates an expected call of ImageInspectWithRaw
func (mr *MockImageAPIClientMockRecorder) ImageInspectWithRaw(ctx, image interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageInspectWithRaw", reflect.TypeOf((*MockImageAPIClient)(nil).ImageInspectWithRaw), ctx, image)
}

// ImageList mocks base method
func (m *MockImageAPIClient) ImageList(ctx context.Context, options types.ImageListOptions) ([]types.ImageSummary, error) {
	ret := m.ctrl.Call(m, "ImageList", ctx, options)
	ret0, _ := ret[0].([]types.ImageSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageList indicates an expected call of ImageList
func (mr *MockImageAPIClientMockRecorder) ImageList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageList", reflect.TypeOf((*MockImageAPIClient)(nil).ImageList), ctx, options)
}

// ImageLoad mocks base method
func (m *MockImageAPIClient) ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error) {
	ret := m.ctrl.Call(m, "ImageLoad", ctx, input, quiet)
	ret0, _ := ret[0].(types.ImageLoadResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageLoad indicates an expected call of ImageLoad
func (mr *MockImageAPIClientMockRecorder) ImageLoad(ctx, input, quiet interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageLoad", reflect.TypeOf((*MockImageAPIClient)(nil).ImageLoad), ctx, input, quiet)
}

// ImagePull mocks base method
func (m *MockImageAPIClient) ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImagePull", ctx, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePull indicates an expected call of ImagePull
func (mr *MockImageAPIClientMockRecorder) ImagePull(ctx, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePull", reflect.TypeOf((*MockImageAPIClient)(nil).ImagePull), ctx, ref, options)
}

// ImagePush mocks base method
func (m *MockImageAPIClient) ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImagePush", ctx, ref, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePush indicates an expected call of ImagePush
func (mr *MockImageAPIClientMockRecorder) ImagePush(ctx, ref, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePush", reflect.TypeOf((*MockImageAPIClient)(nil).ImagePush), ctx, ref, options)
}

// ImageRemove mocks base method
func (m *MockImageAPIClient) ImageRemove(ctx context.Context, image string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
	ret := m.ctrl.Call(m, "ImageRemove", ctx, image, options)
	ret0, _ := ret[0].([]types.ImageDeleteResponseItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageRemove indicates an expected call of ImageRemove
func (mr *MockImageAPIClientMockRecorder) ImageRemove(ctx, image, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageRemove", reflect.TypeOf((*MockImageAPIClient)(nil).ImageRemove), ctx, image, options)
}

// ImageSearch mocks base method
func (m *MockImageAPIClient) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) {
	ret := m.ctrl.Call(m, "ImageSearch", ctx, term, options)
	ret0, _ := ret[0].([]registry.SearchResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageSearch indicates an expected call of ImageSearch
func (mr *MockImageAPIClientMockRecorder) ImageSearch(ctx, term, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageSearch", reflect.TypeOf((*MockImageAPIClient)(nil).ImageSearch), ctx, term, options)
}

// ImageSave mocks base method
func (m *MockImageAPIClient) ImageSave(ctx context.Context, images []string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ImageSave", ctx, images)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageSave indicates an expected call of ImageSave
func (mr *MockImageAPIClientMockRecorder) ImageSave(ctx, images interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageSave", reflect.TypeOf((*MockImageAPIClient)(nil).ImageSave), ctx, images)
}

// ImageTag mocks base method
func (m *MockImageAPIClient) ImageTag(ctx context.Context, image, ref string) error {
	ret := m.ctrl.Call(m, "ImageTag", ctx, image, ref)
	ret0, _ := ret[0].(error)
	return ret0
}

// ImageTag indicates an expected call of ImageTag
func (mr *MockImageAPIClientMockRecorder) ImageTag(ctx, image, ref interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageTag", reflect.TypeOf((*MockImageAPIClient)(nil).ImageTag), ctx, image, ref)
}

// ImagesPrune mocks base method
func (m *MockImageAPIClient) ImagesPrune(ctx context.Context, pruneFilter filters.Args) (types.ImagesPruneReport, error) {
	ret := m.ctrl.Call(m, "ImagesPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.ImagesPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagesPrune indicates an expected call of ImagesPrune
func (mr *MockImageAPIClientMockRecorder) ImagesPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagesPrune", reflect.TypeOf((*MockImageAPIClient)(nil).ImagesPrune), ctx, pruneFilter)
}

// MockNetworkAPIClient is a mock of NetworkAPIClient interface
type MockNetworkAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkAPIClientMockRecorder
}

// MockNetworkAPIClientMockRecorder is the mock recorder for MockNetworkAPIClient
type MockNetworkAPIClientMockRecorder struct {
	mock *MockNetworkAPIClient
}

// NewMockNetworkAPIClient creates a new mock instance
func NewMockNetworkAPIClient(ctrl *gomock.Controller) *MockNetworkAPIClient {
	mock := &MockNetworkAPIClient{ctrl: ctrl}
	mock.recorder = &MockNetworkAPIClientMockRecorder{mock}
	return mock
}

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

// NetworkConnect mocks base method
func (m *MockNetworkAPIClient) NetworkConnect(ctx context.Context, networkID, container string, config *network.EndpointSettings) error {
	ret := m.ctrl.Call(m, "NetworkConnect", ctx, networkID, container, config)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkConnect indicates an expected call of NetworkConnect
func (mr *MockNetworkAPIClientMockRecorder) NetworkConnect(ctx, networkID, container, config interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkConnect", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkConnect), ctx, networkID, container, config)
}

// NetworkCreate mocks base method
func (m *MockNetworkAPIClient) NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (types.NetworkCreateResponse, error) {
	ret := m.ctrl.Call(m, "NetworkCreate", ctx, name, options)
	ret0, _ := ret[0].(types.NetworkCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkCreate indicates an expected call of NetworkCreate
func (mr *MockNetworkAPIClientMockRecorder) NetworkCreate(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkCreate", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkCreate), ctx, name, options)
}

// NetworkDisconnect mocks base method
func (m *MockNetworkAPIClient) NetworkDisconnect(ctx context.Context, networkID, container string, force bool) error {
	ret := m.ctrl.Call(m, "NetworkDisconnect", ctx, networkID, container, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkDisconnect indicates an expected call of NetworkDisconnect
func (mr *MockNetworkAPIClientMockRecorder) NetworkDisconnect(ctx, networkID, container, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkDisconnect", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkDisconnect), ctx, networkID, container, force)
}

// NetworkInspect mocks base method
func (m *MockNetworkAPIClient) NetworkInspect(ctx context.Context, networkID string, verbose bool) (types.NetworkResource, error) {
	ret := m.ctrl.Call(m, "NetworkInspect", ctx, networkID, verbose)
	ret0, _ := ret[0].(types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkInspect indicates an expected call of NetworkInspect
func (mr *MockNetworkAPIClientMockRecorder) NetworkInspect(ctx, networkID, verbose interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInspect", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkInspect), ctx, networkID, verbose)
}

// NetworkInspectWithRaw mocks base method
func (m *MockNetworkAPIClient) NetworkInspectWithRaw(ctx context.Context, networkID string, verbose bool) (types.NetworkResource, []byte, error) {
	ret := m.ctrl.Call(m, "NetworkInspectWithRaw", ctx, networkID, verbose)
	ret0, _ := ret[0].(types.NetworkResource)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NetworkInspectWithRaw indicates an expected call of NetworkInspectWithRaw
func (mr *MockNetworkAPIClientMockRecorder) NetworkInspectWithRaw(ctx, networkID, verbose interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInspectWithRaw", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkInspectWithRaw), ctx, networkID, verbose)
}

// NetworkList mocks base method
func (m *MockNetworkAPIClient) NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error) {
	ret := m.ctrl.Call(m, "NetworkList", ctx, options)
	ret0, _ := ret[0].([]types.NetworkResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkList indicates an expected call of NetworkList
func (mr *MockNetworkAPIClientMockRecorder) NetworkList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkList", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkList), ctx, options)
}

// NetworkRemove mocks base method
func (m *MockNetworkAPIClient) NetworkRemove(ctx context.Context, networkID string) error {
	ret := m.ctrl.Call(m, "NetworkRemove", ctx, networkID)
	ret0, _ := ret[0].(error)
	return ret0
}

// NetworkRemove indicates an expected call of NetworkRemove
func (mr *MockNetworkAPIClientMockRecorder) NetworkRemove(ctx, networkID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkRemove", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkRemove), ctx, networkID)
}

// NetworksPrune mocks base method
func (m *MockNetworkAPIClient) NetworksPrune(ctx context.Context, pruneFilter filters.Args) (types.NetworksPruneReport, error) {
	ret := m.ctrl.Call(m, "NetworksPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.NetworksPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworksPrune indicates an expected call of NetworksPrune
func (mr *MockNetworkAPIClientMockRecorder) NetworksPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworksPrune", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworksPrune), ctx, pruneFilter)
}

// MockNodeAPIClient is a mock of NodeAPIClient interface
type MockNodeAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockNodeAPIClientMockRecorder
}

// MockNodeAPIClientMockRecorder is the mock recorder for MockNodeAPIClient
type MockNodeAPIClientMockRecorder struct {
	mock *MockNodeAPIClient
}

// NewMockNodeAPIClient creates a new mock instance
func NewMockNodeAPIClient(ctrl *gomock.Controller) *MockNodeAPIClient {
	mock := &MockNodeAPIClient{ctrl: ctrl}
	mock.recorder = &MockNodeAPIClientMockRecorder{mock}
	return mock
}

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

// NodeInspectWithRaw mocks base method
func (m *MockNodeAPIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
	ret := m.ctrl.Call(m, "NodeInspectWithRaw", ctx, nodeID)
	ret0, _ := ret[0].(swarm.Node)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NodeInspectWithRaw indicates an expected call of NodeInspectWithRaw
func (mr *MockNodeAPIClientMockRecorder) NodeInspectWithRaw(ctx, nodeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeInspectWithRaw", reflect.TypeOf((*MockNodeAPIClient)(nil).NodeInspectWithRaw), ctx, nodeID)
}

// NodeList mocks base method
func (m *MockNodeAPIClient) NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
	ret := m.ctrl.Call(m, "NodeList", ctx, options)
	ret0, _ := ret[0].([]swarm.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NodeList indicates an expected call of NodeList
func (mr *MockNodeAPIClientMockRecorder) NodeList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeList", reflect.TypeOf((*MockNodeAPIClient)(nil).NodeList), ctx, options)
}

// NodeRemove mocks base method
func (m *MockNodeAPIClient) NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error {
	ret := m.ctrl.Call(m, "NodeRemove", ctx, nodeID, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// NodeRemove indicates an expected call of NodeRemove
func (mr *MockNodeAPIClientMockRecorder) NodeRemove(ctx, nodeID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeRemove", reflect.TypeOf((*MockNodeAPIClient)(nil).NodeRemove), ctx, nodeID, options)
}

// NodeUpdate mocks base method
func (m *MockNodeAPIClient) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error {
	ret := m.ctrl.Call(m, "NodeUpdate", ctx, nodeID, version, node)
	ret0, _ := ret[0].(error)
	return ret0
}

// NodeUpdate indicates an expected call of NodeUpdate
func (mr *MockNodeAPIClientMockRecorder) NodeUpdate(ctx, nodeID, version, node interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeUpdate", reflect.TypeOf((*MockNodeAPIClient)(nil).NodeUpdate), ctx, nodeID, version, node)
}

// MockPluginAPIClient is a mock of PluginAPIClient interface
type MockPluginAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockPluginAPIClientMockRecorder
}

// MockPluginAPIClientMockRecorder is the mock recorder for MockPluginAPIClient
type MockPluginAPIClientMockRecorder struct {
	mock *MockPluginAPIClient
}

// NewMockPluginAPIClient creates a new mock instance
func NewMockPluginAPIClient(ctrl *gomock.Controller) *MockPluginAPIClient {
	mock := &MockPluginAPIClient{ctrl: ctrl}
	mock.recorder = &MockPluginAPIClientMockRecorder{mock}
	return mock
}

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

// PluginList mocks base method
func (m *MockPluginAPIClient) PluginList(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error) {
	ret := m.ctrl.Call(m, "PluginList", ctx, filter)
	ret0, _ := ret[0].(types.PluginsListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginList indicates an expected call of PluginList
func (mr *MockPluginAPIClientMockRecorder) PluginList(ctx, filter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginList", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginList), ctx, filter)
}

// PluginRemove mocks base method
func (m *MockPluginAPIClient) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error {
	ret := m.ctrl.Call(m, "PluginRemove", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginRemove indicates an expected call of PluginRemove
func (mr *MockPluginAPIClientMockRecorder) PluginRemove(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginRemove", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginRemove), ctx, name, options)
}

// PluginEnable mocks base method
func (m *MockPluginAPIClient) PluginEnable(ctx context.Context, name string, options types.PluginEnableOptions) error {
	ret := m.ctrl.Call(m, "PluginEnable", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginEnable indicates an expected call of PluginEnable
func (mr *MockPluginAPIClientMockRecorder) PluginEnable(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginEnable", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginEnable), ctx, name, options)
}

// PluginDisable mocks base method
func (m *MockPluginAPIClient) PluginDisable(ctx context.Context, name string, options types.PluginDisableOptions) error {
	ret := m.ctrl.Call(m, "PluginDisable", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginDisable indicates an expected call of PluginDisable
func (mr *MockPluginAPIClientMockRecorder) PluginDisable(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginDisable", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginDisable), ctx, name, options)
}

// PluginInstall mocks base method
func (m *MockPluginAPIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginInstall", ctx, name, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginInstall indicates an expected call of PluginInstall
func (mr *MockPluginAPIClientMockRecorder) PluginInstall(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginInstall", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginInstall), ctx, name, options)
}

// PluginUpgrade mocks base method
func (m *MockPluginAPIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginUpgrade", ctx, name, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginUpgrade indicates an expected call of PluginUpgrade
func (mr *MockPluginAPIClientMockRecorder) PluginUpgrade(ctx, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginUpgrade", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginUpgrade), ctx, name, options)
}

// PluginPush mocks base method
func (m *MockPluginAPIClient) PluginPush(ctx context.Context, name, registryAuth string) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "PluginPush", ctx, name, registryAuth)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PluginPush indicates an expected call of PluginPush
func (mr *MockPluginAPIClientMockRecorder) PluginPush(ctx, name, registryAuth interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginPush", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginPush), ctx, name, registryAuth)
}

// PluginSet mocks base method
func (m *MockPluginAPIClient) PluginSet(ctx context.Context, name string, args []string) error {
	ret := m.ctrl.Call(m, "PluginSet", ctx, name, args)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginSet indicates an expected call of PluginSet
func (mr *MockPluginAPIClientMockRecorder) PluginSet(ctx, name, args interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginSet", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginSet), ctx, name, args)
}

// PluginInspectWithRaw mocks base method
func (m *MockPluginAPIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
	ret := m.ctrl.Call(m, "PluginInspectWithRaw", ctx, name)
	ret0, _ := ret[0].(*types.Plugin)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PluginInspectWithRaw indicates an expected call of PluginInspectWithRaw
func (mr *MockPluginAPIClientMockRecorder) PluginInspectWithRaw(ctx, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginInspectWithRaw", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginInspectWithRaw), ctx, name)
}

// PluginCreate mocks base method
func (m *MockPluginAPIClient) PluginCreate(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions) error {
	ret := m.ctrl.Call(m, "PluginCreate", ctx, createContext, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// PluginCreate indicates an expected call of PluginCreate
func (mr *MockPluginAPIClientMockRecorder) PluginCreate(ctx, createContext, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PluginCreate", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginCreate), ctx, createContext, options)
}

// MockServiceAPIClient is a mock of ServiceAPIClient interface
type MockServiceAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAPIClientMockRecorder
}

// MockServiceAPIClientMockRecorder is the mock recorder for MockServiceAPIClient
type MockServiceAPIClientMockRecorder struct {
	mock *MockServiceAPIClient
}

// NewMockServiceAPIClient creates a new mock instance
func NewMockServiceAPIClient(ctrl *gomock.Controller) *MockServiceAPIClient {
	mock := &MockServiceAPIClient{ctrl: ctrl}
	mock.recorder = &MockServiceAPIClientMockRecorder{mock}
	return mock
}

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

// ServiceCreate mocks base method
func (m *MockServiceAPIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error) {
	ret := m.ctrl.Call(m, "ServiceCreate", ctx, service, options)
	ret0, _ := ret[0].(types.ServiceCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceCreate indicates an expected call of ServiceCreate
func (mr *MockServiceAPIClientMockRecorder) ServiceCreate(ctx, service, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceCreate", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceCreate), ctx, service, options)
}

// ServiceInspectWithRaw mocks base method
func (m *MockServiceAPIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string, options types.ServiceInspectOptions) (swarm.Service, []byte, error) {
	ret := m.ctrl.Call(m, "ServiceInspectWithRaw", ctx, serviceID, options)
	ret0, _ := ret[0].(swarm.Service)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ServiceInspectWithRaw indicates an expected call of ServiceInspectWithRaw
func (mr *MockServiceAPIClientMockRecorder) ServiceInspectWithRaw(ctx, serviceID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceInspectWithRaw", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceInspectWithRaw), ctx, serviceID, options)
}

// ServiceList mocks base method
func (m *MockServiceAPIClient) ServiceList(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
	ret := m.ctrl.Call(m, "ServiceList", ctx, options)
	ret0, _ := ret[0].([]swarm.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceList indicates an expected call of ServiceList
func (mr *MockServiceAPIClientMockRecorder) ServiceList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceList", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceList), ctx, options)
}

// ServiceRemove mocks base method
func (m *MockServiceAPIClient) ServiceRemove(ctx context.Context, serviceID string) error {
	ret := m.ctrl.Call(m, "ServiceRemove", ctx, serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ServiceRemove indicates an expected call of ServiceRemove
func (mr *MockServiceAPIClientMockRecorder) ServiceRemove(ctx, serviceID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceRemove", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceRemove), ctx, serviceID)
}

// ServiceUpdate mocks base method
func (m *MockServiceAPIClient) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) (types.ServiceUpdateResponse, error) {
	ret := m.ctrl.Call(m, "ServiceUpdate", ctx, serviceID, version, service, options)
	ret0, _ := ret[0].(types.ServiceUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceUpdate indicates an expected call of ServiceUpdate
func (mr *MockServiceAPIClientMockRecorder) ServiceUpdate(ctx, serviceID, version, service, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceUpdate", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceUpdate), ctx, serviceID, version, service, options)
}

// ServiceLogs mocks base method
func (m *MockServiceAPIClient) ServiceLogs(ctx context.Context, serviceID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "ServiceLogs", ctx, serviceID, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServiceLogs indicates an expected call of ServiceLogs
func (mr *MockServiceAPIClientMockRecorder) ServiceLogs(ctx, serviceID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceLogs", reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceLogs), ctx, serviceID, options)
}

// TaskLogs mocks base method
func (m *MockServiceAPIClient) TaskLogs(ctx context.Context, taskID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := m.ctrl.Call(m, "TaskLogs", ctx, taskID, options)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskLogs indicates an expected call of TaskLogs
func (mr *MockServiceAPIClientMockRecorder) TaskLogs(ctx, taskID, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskLogs", reflect.TypeOf((*MockServiceAPIClient)(nil).TaskLogs), ctx, taskID, options)
}

// TaskInspectWithRaw mocks base method
func (m *MockServiceAPIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
	ret := m.ctrl.Call(m, "TaskInspectWithRaw", ctx, taskID)
	ret0, _ := ret[0].(swarm.Task)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// TaskInspectWithRaw indicates an expected call of TaskInspectWithRaw
func (mr *MockServiceAPIClientMockRecorder) TaskInspectWithRaw(ctx, taskID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskInspectWithRaw", reflect.TypeOf((*MockServiceAPIClient)(nil).TaskInspectWithRaw), ctx, taskID)
}

// TaskList mocks base method
func (m *MockServiceAPIClient) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
	ret := m.ctrl.Call(m, "TaskList", ctx, options)
	ret0, _ := ret[0].([]swarm.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskList indicates an expected call of TaskList
func (mr *MockServiceAPIClientMockRecorder) TaskList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskList", reflect.TypeOf((*MockServiceAPIClient)(nil).TaskList), ctx, options)
}

// MockSwarmAPIClient is a mock of SwarmAPIClient interface
type MockSwarmAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockSwarmAPIClientMockRecorder
}

// MockSwarmAPIClientMockRecorder is the mock recorder for MockSwarmAPIClient
type MockSwarmAPIClientMockRecorder struct {
	mock *MockSwarmAPIClient
}

// NewMockSwarmAPIClient creates a new mock instance
func NewMockSwarmAPIClient(ctrl *gomock.Controller) *MockSwarmAPIClient {
	mock := &MockSwarmAPIClient{ctrl: ctrl}
	mock.recorder = &MockSwarmAPIClientMockRecorder{mock}
	return mock
}

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

// SwarmInit mocks base method
func (m *MockSwarmAPIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
	ret := m.ctrl.Call(m, "SwarmInit", ctx, req)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmInit indicates an expected call of SwarmInit
func (mr *MockSwarmAPIClientMockRecorder) SwarmInit(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmInit", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmInit), ctx, req)
}

// SwarmJoin mocks base method
func (m *MockSwarmAPIClient) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error {
	ret := m.ctrl.Call(m, "SwarmJoin", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmJoin indicates an expected call of SwarmJoin
func (mr *MockSwarmAPIClientMockRecorder) SwarmJoin(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmJoin", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmJoin), ctx, req)
}

// SwarmGetUnlockKey mocks base method
func (m *MockSwarmAPIClient) SwarmGetUnlockKey(ctx context.Context) (types.SwarmUnlockKeyResponse, error) {
	ret := m.ctrl.Call(m, "SwarmGetUnlockKey", ctx)
	ret0, _ := ret[0].(types.SwarmUnlockKeyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmGetUnlockKey indicates an expected call of SwarmGetUnlockKey
func (mr *MockSwarmAPIClientMockRecorder) SwarmGetUnlockKey(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmGetUnlockKey", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmGetUnlockKey), ctx)
}

// SwarmUnlock mocks base method
func (m *MockSwarmAPIClient) SwarmUnlock(ctx context.Context, req swarm.UnlockRequest) error {
	ret := m.ctrl.Call(m, "SwarmUnlock", ctx, req)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmUnlock indicates an expected call of SwarmUnlock
func (mr *MockSwarmAPIClientMockRecorder) SwarmUnlock(ctx, req interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmUnlock", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmUnlock), ctx, req)
}

// SwarmLeave mocks base method
func (m *MockSwarmAPIClient) SwarmLeave(ctx context.Context, force bool) error {
	ret := m.ctrl.Call(m, "SwarmLeave", ctx, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmLeave indicates an expected call of SwarmLeave
func (mr *MockSwarmAPIClientMockRecorder) SwarmLeave(ctx, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmLeave", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmLeave), ctx, force)
}

// SwarmInspect mocks base method
func (m *MockSwarmAPIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
	ret := m.ctrl.Call(m, "SwarmInspect", ctx)
	ret0, _ := ret[0].(swarm.Swarm)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SwarmInspect indicates an expected call of SwarmInspect
func (mr *MockSwarmAPIClientMockRecorder) SwarmInspect(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmInspect", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmInspect), ctx)
}

// SwarmUpdate mocks base method
func (m *MockSwarmAPIClient) SwarmUpdate(ctx context.Context, version swarm.Version, swarm swarm.Spec, flags swarm.UpdateFlags) error {
	ret := m.ctrl.Call(m, "SwarmUpdate", ctx, version, swarm, flags)
	ret0, _ := ret[0].(error)
	return ret0
}

// SwarmUpdate indicates an expected call of SwarmUpdate
func (mr *MockSwarmAPIClientMockRecorder) SwarmUpdate(ctx, version, swarm, flags interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmUpdate", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmUpdate), ctx, version, swarm, flags)
}

// MockSystemAPIClient is a mock of SystemAPIClient interface
type MockSystemAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockSystemAPIClientMockRecorder
}

// MockSystemAPIClientMockRecorder is the mock recorder for MockSystemAPIClient
type MockSystemAPIClientMockRecorder struct {
	mock *MockSystemAPIClient
}

// NewMockSystemAPIClient creates a new mock instance
func NewMockSystemAPIClient(ctrl *gomock.Controller) *MockSystemAPIClient {
	mock := &MockSystemAPIClient{ctrl: ctrl}
	mock.recorder = &MockSystemAPIClientMockRecorder{mock}
	return mock
}

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

// Events mocks base method
func (m *MockSystemAPIClient) Events(ctx context.Context, options types.EventsOptions) (<-chan events.Message, <-chan error) {
	ret := m.ctrl.Call(m, "Events", ctx, options)
	ret0, _ := ret[0].(<-chan events.Message)
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// Events indicates an expected call of Events
func (mr *MockSystemAPIClientMockRecorder) Events(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Events", reflect.TypeOf((*MockSystemAPIClient)(nil).Events), ctx, options)
}

// Info mocks base method
func (m *MockSystemAPIClient) Info(ctx context.Context) (types.Info, error) {
	ret := m.ctrl.Call(m, "Info", ctx)
	ret0, _ := ret[0].(types.Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Info indicates an expected call of Info
func (mr *MockSystemAPIClientMockRecorder) Info(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockSystemAPIClient)(nil).Info), ctx)
}

// RegistryLogin mocks base method
func (m *MockSystemAPIClient) RegistryLogin(ctx context.Context, auth types.AuthConfig) (registry.AuthenticateOKBody, error) {
	ret := m.ctrl.Call(m, "RegistryLogin", ctx, auth)
	ret0, _ := ret[0].(registry.AuthenticateOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegistryLogin indicates an expected call of RegistryLogin
func (mr *MockSystemAPIClientMockRecorder) RegistryLogin(ctx, auth interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegistryLogin", reflect.TypeOf((*MockSystemAPIClient)(nil).RegistryLogin), ctx, auth)
}

// DiskUsage mocks base method
func (m *MockSystemAPIClient) DiskUsage(ctx context.Context) (types.DiskUsage, error) {
	ret := m.ctrl.Call(m, "DiskUsage", ctx)
	ret0, _ := ret[0].(types.DiskUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiskUsage indicates an expected call of DiskUsage
func (mr *MockSystemAPIClientMockRecorder) DiskUsage(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiskUsage", reflect.TypeOf((*MockSystemAPIClient)(nil).DiskUsage), ctx)
}

// Ping mocks base method
func (m *MockSystemAPIClient) Ping(ctx context.Context) (types.Ping, error) {
	ret := m.ctrl.Call(m, "Ping", ctx)
	ret0, _ := ret[0].(types.Ping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ping indicates an expected call of Ping
func (mr *MockSystemAPIClientMockRecorder) Ping(ctx interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockSystemAPIClient)(nil).Ping), ctx)
}

// MockVolumeAPIClient is a mock of VolumeAPIClient interface
type MockVolumeAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeAPIClientMockRecorder
}

// MockVolumeAPIClientMockRecorder is the mock recorder for MockVolumeAPIClient
type MockVolumeAPIClientMockRecorder struct {
	mock *MockVolumeAPIClient
}

// NewMockVolumeAPIClient creates a new mock instance
func NewMockVolumeAPIClient(ctrl *gomock.Controller) *MockVolumeAPIClient {
	mock := &MockVolumeAPIClient{ctrl: ctrl}
	mock.recorder = &MockVolumeAPIClientMockRecorder{mock}
	return mock
}

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

// VolumeCreate mocks base method
func (m *MockVolumeAPIClient) VolumeCreate(ctx context.Context, options volume.VolumesCreateBody) (types.Volume, error) {
	ret := m.ctrl.Call(m, "VolumeCreate", ctx, options)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeCreate indicates an expected call of VolumeCreate
func (mr *MockVolumeAPIClientMockRecorder) VolumeCreate(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeCreate", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeCreate), ctx, options)
}

// VolumeInspect mocks base method
func (m *MockVolumeAPIClient) VolumeInspect(ctx context.Context, volumeID string) (types.Volume, error) {
	ret := m.ctrl.Call(m, "VolumeInspect", ctx, volumeID)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeInspect indicates an expected call of VolumeInspect
func (mr *MockVolumeAPIClientMockRecorder) VolumeInspect(ctx, volumeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeInspect", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeInspect), ctx, volumeID)
}

// VolumeInspectWithRaw mocks base method
func (m *MockVolumeAPIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (types.Volume, []byte, error) {
	ret := m.ctrl.Call(m, "VolumeInspectWithRaw", ctx, volumeID)
	ret0, _ := ret[0].(types.Volume)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// VolumeInspectWithRaw indicates an expected call of VolumeInspectWithRaw
func (mr *MockVolumeAPIClientMockRecorder) VolumeInspectWithRaw(ctx, volumeID interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeInspectWithRaw", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeInspectWithRaw), ctx, volumeID)
}

// VolumeList mocks base method
func (m *MockVolumeAPIClient) VolumeList(ctx context.Context, filter filters.Args) (volume.VolumesListOKBody, error) {
	ret := m.ctrl.Call(m, "VolumeList", ctx, filter)
	ret0, _ := ret[0].(volume.VolumesListOKBody)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeList indicates an expected call of VolumeList
func (mr *MockVolumeAPIClientMockRecorder) VolumeList(ctx, filter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeList", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeList), ctx, filter)
}

// VolumeRemove mocks base method
func (m *MockVolumeAPIClient) VolumeRemove(ctx context.Context, volumeID string, force bool) error {
	ret := m.ctrl.Call(m, "VolumeRemove", ctx, volumeID, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// VolumeRemove indicates an expected call of VolumeRemove
func (mr *MockVolumeAPIClientMockRecorder) VolumeRemove(ctx, volumeID, force interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeRemove", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeRemove), ctx, volumeID, force)
}

// VolumesPrune mocks base method
func (m *MockVolumeAPIClient) VolumesPrune(ctx context.Context, pruneFilter filters.Args) (types.VolumesPruneReport, error) {
	ret := m.ctrl.Call(m, "VolumesPrune", ctx, pruneFilter)
	ret0, _ := ret[0].(types.VolumesPruneReport)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumesPrune indicates an expected call of VolumesPrune
func (mr *MockVolumeAPIClientMockRecorder) VolumesPrune(ctx, pruneFilter interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumesPrune", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumesPrune), ctx, pruneFilter)
}

// MockSecretAPIClient is a mock of SecretAPIClient interface
type MockSecretAPIClient struct {
	ctrl     *gomock.Controller
	recorder *MockSecretAPIClientMockRecorder
}

// MockSecretAPIClientMockRecorder is the mock recorder for MockSecretAPIClient
type MockSecretAPIClientMockRecorder struct {
	mock *MockSecretAPIClient
}

// NewMockSecretAPIClient creates a new mock instance
func NewMockSecretAPIClient(ctrl *gomock.Controller) *MockSecretAPIClient {
	mock := &MockSecretAPIClient{ctrl: ctrl}
	mock.recorder = &MockSecretAPIClientMockRecorder{mock}
	return mock
}

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

// SecretList mocks base method
func (m *MockSecretAPIClient) SecretList(ctx context.Context, options types.SecretListOptions) ([]swarm.Secret, error) {
	ret := m.ctrl.Call(m, "SecretList", ctx, options)
	ret0, _ := ret[0].([]swarm.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SecretList indicates an expected call of SecretList
func (mr *MockSecretAPIClientMockRecorder) SecretList(ctx, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretList", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretList), ctx, options)
}

// SecretCreate mocks base method
func (m *MockSecretAPIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (types.SecretCreateResponse, error) {
	ret := m.ctrl.Call(m, "SecretCreate", ctx, secret)
	ret0, _ := ret[0].(types.SecretCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SecretCreate indicates an expected call of SecretCreate
func (mr *MockSecretAPIClientMockRecorder) SecretCreate(ctx, secret interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretCreate", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretCreate), ctx, secret)
}

// SecretRemove mocks base method
func (m *MockSecretAPIClient) SecretRemove(ctx context.Context, id string) error {
	ret := m.ctrl.Call(m, "SecretRemove", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// SecretRemove indicates an expected call of SecretRemove
func (mr *MockSecretAPIClientMockRecorder) SecretRemove(ctx, id interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretRemove", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretRemove), ctx, id)
}

// SecretInspectWithRaw mocks base method
func (m *MockSecretAPIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error) {
	ret := m.ctrl.Call(m, "SecretInspectWithRaw", ctx, name)
	ret0, _ := ret[0].(swarm.Secret)
	ret1, _ := ret[1].([]byte)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SecretInspectWithRaw indicates an expected call of SecretInspectWithRaw
func (mr *MockSecretAPIClientMockRecorder) SecretInspectWithRaw(ctx, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretInspectWithRaw", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretInspectWithRaw), ctx, name)
}

// SecretUpdate mocks base method
func (m *MockSecretAPIClient) SecretUpdate(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error {
	ret := m.ctrl.Call(m, "SecretUpdate", ctx, id, version, secret)
	ret0, _ := ret[0].(error)
	return ret0
}

// SecretUpdate indicates an expected call of SecretUpdate
func (mr *MockSecretAPIClientMockRecorder) SecretUpdate(ctx, id, version, secret interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecretUpdate", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretUpdate), ctx, id, version, secret)
}