common_api_client.go

// Code generated by mockery v1.0.0. DO NOT EDIT.

// CLOSE THIS FILE AS QUICKLY AS POSSIBLE

package docker

import container "github.com/docker/docker/api/types/container"
import context "context"
import events "github.com/docker/docker/api/types/events"
import filters "github.com/docker/docker/api/types/filters"
import io "io"
import mock "github.com/stretchr/testify/mock"
import network "github.com/docker/docker/api/types/network"
import registry "github.com/docker/docker/api/types/registry"
import swarm "github.com/docker/docker/api/types/swarm"
import time "time"
import types "github.com/docker/docker/api/types"
import volume "github.com/docker/docker/api/types/volume"

// CommonAPIClient is an autogenerated mock type for the CommonAPIClient type
type CommonAPIClient struct {
	mock.Mock
}

// ClientVersion provides a mock function with given fields:
func (_m *CommonAPIClient) ClientVersion() string {
	ret := _m.Called()

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

// ContainerAttach provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerAttach(ctx context.Context, _a1 string, options types.ContainerAttachOptions) (types.HijackedResponse, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 types.HijackedResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerAttachOptions) types.HijackedResponse); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Get(0).(types.HijackedResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ContainerAttachOptions) error); ok {
		r1 = rf(ctx, _a1, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerCommit provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerCommit(ctx context.Context, _a1 string, options types.ContainerCommitOptions) (types.IDResponse, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 types.IDResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerCommitOptions) types.IDResponse); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Get(0).(types.IDResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ContainerCommitOptions) error); ok {
		r1 = rf(ctx, _a1, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerCreate provides a mock function with given fields: ctx, config, hostConfig, networkingConfig, containerName
func (_m *CommonAPIClient) ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, containerName string) (container.ContainerCreateCreatedBody, error) {
	ret := _m.Called(ctx, config, hostConfig, networkingConfig, containerName)

	var r0 container.ContainerCreateCreatedBody
	if rf, ok := ret.Get(0).(func(context.Context, *container.Config, *container.HostConfig, *network.NetworkingConfig, string) container.ContainerCreateCreatedBody); ok {
		r0 = rf(ctx, config, hostConfig, networkingConfig, containerName)
	} else {
		r0 = ret.Get(0).(container.ContainerCreateCreatedBody)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *container.Config, *container.HostConfig, *network.NetworkingConfig, string) error); ok {
		r1 = rf(ctx, config, hostConfig, networkingConfig, containerName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerDiff provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerDiff(ctx context.Context, _a1 string) ([]types.ContainerChange, error) {
	ret := _m.Called(ctx, _a1)

	var r0 []types.ContainerChange
	if rf, ok := ret.Get(0).(func(context.Context, string) []types.ContainerChange); ok {
		r0 = rf(ctx, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.ContainerChange)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerExecAttach provides a mock function with given fields: ctx, execID, config
func (_m *CommonAPIClient) ContainerExecAttach(ctx context.Context, execID string, config types.ExecConfig) (types.HijackedResponse, error) {
	ret := _m.Called(ctx, execID, config)

	var r0 types.HijackedResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ExecConfig) types.HijackedResponse); ok {
		r0 = rf(ctx, execID, config)
	} else {
		r0 = ret.Get(0).(types.HijackedResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ExecConfig) error); ok {
		r1 = rf(ctx, execID, config)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerExecCreate provides a mock function with given fields: ctx, _a1, config
func (_m *CommonAPIClient) ContainerExecCreate(ctx context.Context, _a1 string, config types.ExecConfig) (types.IDResponse, error) {
	ret := _m.Called(ctx, _a1, config)

	var r0 types.IDResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ExecConfig) types.IDResponse); ok {
		r0 = rf(ctx, _a1, config)
	} else {
		r0 = ret.Get(0).(types.IDResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ExecConfig) error); ok {
		r1 = rf(ctx, _a1, config)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerExecInspect provides a mock function with given fields: ctx, execID
func (_m *CommonAPIClient) ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error) {
	ret := _m.Called(ctx, execID)

	var r0 types.ContainerExecInspect
	if rf, ok := ret.Get(0).(func(context.Context, string) types.ContainerExecInspect); ok {
		r0 = rf(ctx, execID)
	} else {
		r0 = ret.Get(0).(types.ContainerExecInspect)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, execID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerExecResize provides a mock function with given fields: ctx, execID, options
func (_m *CommonAPIClient) ContainerExecResize(ctx context.Context, execID string, options types.ResizeOptions) error {
	ret := _m.Called(ctx, execID, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ResizeOptions) error); ok {
		r0 = rf(ctx, execID, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerExecStart provides a mock function with given fields: ctx, execID, config
func (_m *CommonAPIClient) ContainerExecStart(ctx context.Context, execID string, config types.ExecStartCheck) error {
	ret := _m.Called(ctx, execID, config)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ExecStartCheck) error); ok {
		r0 = rf(ctx, execID, config)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerExport provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerExport(ctx context.Context, _a1 string) (io.ReadCloser, error) {
	ret := _m.Called(ctx, _a1)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string) io.ReadCloser); ok {
		r0 = rf(ctx, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerInspect provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerInspect(ctx context.Context, _a1 string) (types.ContainerJSON, error) {
	ret := _m.Called(ctx, _a1)

	var r0 types.ContainerJSON
	if rf, ok := ret.Get(0).(func(context.Context, string) types.ContainerJSON); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Get(0).(types.ContainerJSON)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerInspectWithRaw provides a mock function with given fields: ctx, _a1, getSize
func (_m *CommonAPIClient) ContainerInspectWithRaw(ctx context.Context, _a1 string, getSize bool) (types.ContainerJSON, []byte, error) {
	ret := _m.Called(ctx, _a1, getSize)

	var r0 types.ContainerJSON
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) types.ContainerJSON); ok {
		r0 = rf(ctx, _a1, getSize)
	} else {
		r0 = ret.Get(0).(types.ContainerJSON)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string, bool) []byte); ok {
		r1 = rf(ctx, _a1, getSize)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string, bool) error); ok {
		r2 = rf(ctx, _a1, getSize)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ContainerKill provides a mock function with given fields: ctx, _a1, signal
func (_m *CommonAPIClient) ContainerKill(ctx context.Context, _a1 string, signal string) error {
	ret := _m.Called(ctx, _a1, signal)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, _a1, signal)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error) {
	ret := _m.Called(ctx, options)

	var r0 []types.Container
	if rf, ok := ret.Get(0).(func(context.Context, types.ContainerListOptions) []types.Container); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.Container)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.ContainerListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerLogs provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerLogs(ctx context.Context, _a1 string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerLogsOptions) io.ReadCloser); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ContainerLogsOptions) error); ok {
		r1 = rf(ctx, _a1, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerPause provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerPause(ctx context.Context, _a1 string) error {
	ret := _m.Called(ctx, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerRemove provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerRemove(ctx context.Context, _a1 string, options types.ContainerRemoveOptions) error {
	ret := _m.Called(ctx, _a1, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerRemoveOptions) error); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerRename provides a mock function with given fields: ctx, _a1, newContainerName
func (_m *CommonAPIClient) ContainerRename(ctx context.Context, _a1 string, newContainerName string) error {
	ret := _m.Called(ctx, _a1, newContainerName)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, _a1, newContainerName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerResize provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerResize(ctx context.Context, _a1 string, options types.ResizeOptions) error {
	ret := _m.Called(ctx, _a1, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ResizeOptions) error); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerRestart provides a mock function with given fields: ctx, _a1, timeout
func (_m *CommonAPIClient) ContainerRestart(ctx context.Context, _a1 string, timeout *time.Duration) error {
	ret := _m.Called(ctx, _a1, timeout)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *time.Duration) error); ok {
		r0 = rf(ctx, _a1, timeout)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerStart provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ContainerStart(ctx context.Context, _a1 string, options types.ContainerStartOptions) error {
	ret := _m.Called(ctx, _a1, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerStartOptions) error); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerStatPath provides a mock function with given fields: ctx, _a1, path
func (_m *CommonAPIClient) ContainerStatPath(ctx context.Context, _a1 string, path string) (types.ContainerPathStat, error) {
	ret := _m.Called(ctx, _a1, path)

	var r0 types.ContainerPathStat
	if rf, ok := ret.Get(0).(func(context.Context, string, string) types.ContainerPathStat); ok {
		r0 = rf(ctx, _a1, path)
	} else {
		r0 = ret.Get(0).(types.ContainerPathStat)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, _a1, path)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerStats provides a mock function with given fields: ctx, _a1, stream
func (_m *CommonAPIClient) ContainerStats(ctx context.Context, _a1 string, stream bool) (types.ContainerStats, error) {
	ret := _m.Called(ctx, _a1, stream)

	var r0 types.ContainerStats
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) types.ContainerStats); ok {
		r0 = rf(ctx, _a1, stream)
	} else {
		r0 = ret.Get(0).(types.ContainerStats)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = rf(ctx, _a1, stream)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerStop provides a mock function with given fields: ctx, _a1, timeout
func (_m *CommonAPIClient) ContainerStop(ctx context.Context, _a1 string, timeout *time.Duration) error {
	ret := _m.Called(ctx, _a1, timeout)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *time.Duration) error); ok {
		r0 = rf(ctx, _a1, timeout)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerTop provides a mock function with given fields: ctx, _a1, arguments
func (_m *CommonAPIClient) ContainerTop(ctx context.Context, _a1 string, arguments []string) (types.ContainerProcessList, error) {
	ret := _m.Called(ctx, _a1, arguments)

	var r0 types.ContainerProcessList
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) types.ContainerProcessList); ok {
		r0 = rf(ctx, _a1, arguments)
	} else {
		r0 = ret.Get(0).(types.ContainerProcessList)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = rf(ctx, _a1, arguments)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerUnpause provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerUnpause(ctx context.Context, _a1 string) error {
	ret := _m.Called(ctx, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ContainerUpdate provides a mock function with given fields: ctx, _a1, updateConfig
func (_m *CommonAPIClient) ContainerUpdate(ctx context.Context, _a1 string, updateConfig container.UpdateConfig) (container.ContainerUpdateOKBody, error) {
	ret := _m.Called(ctx, _a1, updateConfig)

	var r0 container.ContainerUpdateOKBody
	if rf, ok := ret.Get(0).(func(context.Context, string, container.UpdateConfig) container.ContainerUpdateOKBody); ok {
		r0 = rf(ctx, _a1, updateConfig)
	} else {
		r0 = ret.Get(0).(container.ContainerUpdateOKBody)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, container.UpdateConfig) error); ok {
		r1 = rf(ctx, _a1, updateConfig)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainerWait provides a mock function with given fields: ctx, _a1
func (_m *CommonAPIClient) ContainerWait(ctx context.Context, _a1 string) (int64, error) {
	ret := _m.Called(ctx, _a1)

	var r0 int64
	if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Get(0).(int64)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ContainersPrune provides a mock function with given fields: ctx, pruneFilters
func (_m *CommonAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (types.ContainersPruneReport, error) {
	ret := _m.Called(ctx, pruneFilters)

	var r0 types.ContainersPruneReport
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) types.ContainersPruneReport); ok {
		r0 = rf(ctx, pruneFilters)
	} else {
		r0 = ret.Get(0).(types.ContainersPruneReport)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = rf(ctx, pruneFilters)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyFromContainer provides a mock function with given fields: ctx, _a1, srcPath
func (_m *CommonAPIClient) CopyFromContainer(ctx context.Context, _a1 string, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
	ret := _m.Called(ctx, _a1, srcPath)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, string) io.ReadCloser); ok {
		r0 = rf(ctx, _a1, srcPath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 types.ContainerPathStat
	if rf, ok := ret.Get(1).(func(context.Context, string, string) types.ContainerPathStat); ok {
		r1 = rf(ctx, _a1, srcPath)
	} else {
		r1 = ret.Get(1).(types.ContainerPathStat)
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string, string) error); ok {
		r2 = rf(ctx, _a1, srcPath)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CopyToContainer provides a mock function with given fields: ctx, _a1, path, content, options
func (_m *CommonAPIClient) CopyToContainer(ctx context.Context, _a1 string, path string, content io.Reader, options types.CopyToContainerOptions) error {
	ret := _m.Called(ctx, _a1, path, content, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, io.Reader, types.CopyToContainerOptions) error); ok {
		r0 = rf(ctx, _a1, path, content, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DiskUsage provides a mock function with given fields: ctx
func (_m *CommonAPIClient) DiskUsage(ctx context.Context) (types.DiskUsage, error) {
	ret := _m.Called(ctx)

	var r0 types.DiskUsage
	if rf, ok := ret.Get(0).(func(context.Context) types.DiskUsage); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(types.DiskUsage)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Events provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) Events(ctx context.Context, options types.EventsOptions) (<-chan events.Message, <-chan error) {
	ret := _m.Called(ctx, options)

	var r0 <-chan events.Message
	if rf, ok := ret.Get(0).(func(context.Context, types.EventsOptions) <-chan events.Message); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan events.Message)
		}
	}

	var r1 <-chan error
	if rf, ok := ret.Get(1).(func(context.Context, types.EventsOptions) <-chan error); ok {
		r1 = rf(ctx, options)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(<-chan error)
		}
	}

	return r0, r1
}

// ImageBuild provides a mock function with given fields: ctx, _a1, options
func (_m *CommonAPIClient) ImageBuild(ctx context.Context, _a1 io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 types.ImageBuildResponse
	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, types.ImageBuildOptions) types.ImageBuildResponse); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Get(0).(types.ImageBuildResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, io.Reader, types.ImageBuildOptions) error); ok {
		r1 = rf(ctx, _a1, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageCreate provides a mock function with given fields: ctx, parentReference, options
func (_m *CommonAPIClient) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, parentReference, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImageCreateOptions) io.ReadCloser); ok {
		r0 = rf(ctx, parentReference, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ImageCreateOptions) error); ok {
		r1 = rf(ctx, parentReference, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageHistory provides a mock function with given fields: ctx, image
func (_m *CommonAPIClient) ImageHistory(ctx context.Context, image string) ([]types.ImageHistory, error) {
	ret := _m.Called(ctx, image)

	var r0 []types.ImageHistory
	if rf, ok := ret.Get(0).(func(context.Context, string) []types.ImageHistory); ok {
		r0 = rf(ctx, image)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.ImageHistory)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, image)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageImport provides a mock function with given fields: ctx, source, ref, options
func (_m *CommonAPIClient) ImageImport(ctx context.Context, source types.ImageImportSource, ref string, options types.ImageImportOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, source, ref, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, types.ImageImportSource, string, types.ImageImportOptions) io.ReadCloser); ok {
		r0 = rf(ctx, source, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.ImageImportSource, string, types.ImageImportOptions) error); ok {
		r1 = rf(ctx, source, ref, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageInspectWithRaw provides a mock function with given fields: ctx, image
func (_m *CommonAPIClient) ImageInspectWithRaw(ctx context.Context, image string) (types.ImageInspect, []byte, error) {
	ret := _m.Called(ctx, image)

	var r0 types.ImageInspect
	if rf, ok := ret.Get(0).(func(context.Context, string) types.ImageInspect); ok {
		r0 = rf(ctx, image)
	} else {
		r0 = ret.Get(0).(types.ImageInspect)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, image)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, image)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ImageList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) ImageList(ctx context.Context, options types.ImageListOptions) ([]types.ImageSummary, error) {
	ret := _m.Called(ctx, options)

	var r0 []types.ImageSummary
	if rf, ok := ret.Get(0).(func(context.Context, types.ImageListOptions) []types.ImageSummary); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.ImageSummary)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.ImageListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageLoad provides a mock function with given fields: ctx, input, quiet
func (_m *CommonAPIClient) ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error) {
	ret := _m.Called(ctx, input, quiet)

	var r0 types.ImageLoadResponse
	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, bool) types.ImageLoadResponse); ok {
		r0 = rf(ctx, input, quiet)
	} else {
		r0 = ret.Get(0).(types.ImageLoadResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, io.Reader, bool) error); ok {
		r1 = rf(ctx, input, quiet)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImagePull provides a mock function with given fields: ctx, ref, options
func (_m *CommonAPIClient) ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, ref, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImagePullOptions) io.ReadCloser); ok {
		r0 = rf(ctx, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ImagePullOptions) error); ok {
		r1 = rf(ctx, ref, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImagePush provides a mock function with given fields: ctx, ref, options
func (_m *CommonAPIClient) ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, ref, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImagePushOptions) io.ReadCloser); ok {
		r0 = rf(ctx, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ImagePushOptions) error); ok {
		r1 = rf(ctx, ref, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageRemove provides a mock function with given fields: ctx, image, options
func (_m *CommonAPIClient) ImageRemove(ctx context.Context, image string, options types.ImageRemoveOptions) ([]types.ImageDelete, error) {
	ret := _m.Called(ctx, image, options)

	var r0 []types.ImageDelete
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImageRemoveOptions) []types.ImageDelete); ok {
		r0 = rf(ctx, image, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.ImageDelete)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ImageRemoveOptions) error); ok {
		r1 = rf(ctx, image, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageSave provides a mock function with given fields: ctx, images
func (_m *CommonAPIClient) ImageSave(ctx context.Context, images []string) (io.ReadCloser, error) {
	ret := _m.Called(ctx, images)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, []string) io.ReadCloser); ok {
		r0 = rf(ctx, images)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, images)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageSearch provides a mock function with given fields: ctx, term, options
func (_m *CommonAPIClient) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) {
	ret := _m.Called(ctx, term, options)

	var r0 []registry.SearchResult
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImageSearchOptions) []registry.SearchResult); ok {
		r0 = rf(ctx, term, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]registry.SearchResult)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ImageSearchOptions) error); ok {
		r1 = rf(ctx, term, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImageTag provides a mock function with given fields: ctx, image, ref
func (_m *CommonAPIClient) ImageTag(ctx context.Context, image string, ref string) error {
	ret := _m.Called(ctx, image, ref)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, image, ref)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ImagesPrune provides a mock function with given fields: ctx, pruneFilter
func (_m *CommonAPIClient) ImagesPrune(ctx context.Context, pruneFilter filters.Args) (types.ImagesPruneReport, error) {
	ret := _m.Called(ctx, pruneFilter)

	var r0 types.ImagesPruneReport
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) types.ImagesPruneReport); ok {
		r0 = rf(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(types.ImagesPruneReport)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = rf(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Info provides a mock function with given fields: ctx
func (_m *CommonAPIClient) Info(ctx context.Context) (types.Info, error) {
	ret := _m.Called(ctx)

	var r0 types.Info
	if rf, ok := ret.Get(0).(func(context.Context) types.Info); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(types.Info)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NetworkConnect provides a mock function with given fields: ctx, networkID, _a2, config
func (_m *CommonAPIClient) NetworkConnect(ctx context.Context, networkID string, _a2 string, config *network.EndpointSettings) error {
	ret := _m.Called(ctx, networkID, _a2, config)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *network.EndpointSettings) error); ok {
		r0 = rf(ctx, networkID, _a2, config)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NetworkCreate provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) NetworkCreate(ctx context.Context, name string, options types.NetworkCreate) (types.NetworkCreateResponse, error) {
	ret := _m.Called(ctx, name, options)

	var r0 types.NetworkCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, types.NetworkCreate) types.NetworkCreateResponse); ok {
		r0 = rf(ctx, name, options)
	} else {
		r0 = ret.Get(0).(types.NetworkCreateResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.NetworkCreate) error); ok {
		r1 = rf(ctx, name, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NetworkDisconnect provides a mock function with given fields: ctx, networkID, _a2, force
func (_m *CommonAPIClient) NetworkDisconnect(ctx context.Context, networkID string, _a2 string, force bool) error {
	ret := _m.Called(ctx, networkID, _a2, force)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, bool) error); ok {
		r0 = rf(ctx, networkID, _a2, force)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NetworkInspect provides a mock function with given fields: ctx, networkID
func (_m *CommonAPIClient) NetworkInspect(ctx context.Context, networkID string) (types.NetworkResource, error) {
	ret := _m.Called(ctx, networkID)

	var r0 types.NetworkResource
	if rf, ok := ret.Get(0).(func(context.Context, string) types.NetworkResource); ok {
		r0 = rf(ctx, networkID)
	} else {
		r0 = ret.Get(0).(types.NetworkResource)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, networkID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NetworkInspectWithRaw provides a mock function with given fields: ctx, networkID
func (_m *CommonAPIClient) NetworkInspectWithRaw(ctx context.Context, networkID string) (types.NetworkResource, []byte, error) {
	ret := _m.Called(ctx, networkID)

	var r0 types.NetworkResource
	if rf, ok := ret.Get(0).(func(context.Context, string) types.NetworkResource); ok {
		r0 = rf(ctx, networkID)
	} else {
		r0 = ret.Get(0).(types.NetworkResource)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, networkID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, networkID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// NetworkList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error) {
	ret := _m.Called(ctx, options)

	var r0 []types.NetworkResource
	if rf, ok := ret.Get(0).(func(context.Context, types.NetworkListOptions) []types.NetworkResource); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]types.NetworkResource)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.NetworkListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NetworkRemove provides a mock function with given fields: ctx, networkID
func (_m *CommonAPIClient) NetworkRemove(ctx context.Context, networkID string) error {
	ret := _m.Called(ctx, networkID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, networkID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NetworksPrune provides a mock function with given fields: ctx, pruneFilter
func (_m *CommonAPIClient) NetworksPrune(ctx context.Context, pruneFilter filters.Args) (types.NetworksPruneReport, error) {
	ret := _m.Called(ctx, pruneFilter)

	var r0 types.NetworksPruneReport
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) types.NetworksPruneReport); ok {
		r0 = rf(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(types.NetworksPruneReport)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = rf(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NodeInspectWithRaw provides a mock function with given fields: ctx, nodeID
func (_m *CommonAPIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
	ret := _m.Called(ctx, nodeID)

	var r0 swarm.Node
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Node); ok {
		r0 = rf(ctx, nodeID)
	} else {
		r0 = ret.Get(0).(swarm.Node)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, nodeID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, nodeID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// NodeList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Node
	if rf, ok := ret.Get(0).(func(context.Context, types.NodeListOptions) []swarm.Node); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Node)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.NodeListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NodeRemove provides a mock function with given fields: ctx, nodeID, options
func (_m *CommonAPIClient) NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error {
	ret := _m.Called(ctx, nodeID, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.NodeRemoveOptions) error); ok {
		r0 = rf(ctx, nodeID, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// NodeUpdate provides a mock function with given fields: ctx, nodeID, version, node
func (_m *CommonAPIClient) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error {
	ret := _m.Called(ctx, nodeID, version, node)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, swarm.Version, swarm.NodeSpec) error); ok {
		r0 = rf(ctx, nodeID, version, node)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Ping provides a mock function with given fields: ctx
func (_m *CommonAPIClient) Ping(ctx context.Context) (types.Ping, error) {
	ret := _m.Called(ctx)

	var r0 types.Ping
	if rf, ok := ret.Get(0).(func(context.Context) types.Ping); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(types.Ping)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PluginCreate provides a mock function with given fields: ctx, createContext, options
func (_m *CommonAPIClient) PluginCreate(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions) error {
	ret := _m.Called(ctx, createContext, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, types.PluginCreateOptions) error); ok {
		r0 = rf(ctx, createContext, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PluginDisable provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) PluginDisable(ctx context.Context, name string, options types.PluginDisableOptions) error {
	ret := _m.Called(ctx, name, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginDisableOptions) error); ok {
		r0 = rf(ctx, name, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PluginEnable provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) PluginEnable(ctx context.Context, name string, options types.PluginEnableOptions) error {
	ret := _m.Called(ctx, name, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginEnableOptions) error); ok {
		r0 = rf(ctx, name, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PluginInspectWithRaw provides a mock function with given fields: ctx, name
func (_m *CommonAPIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
	ret := _m.Called(ctx, name)

	var r0 *types.Plugin
	if rf, ok := ret.Get(0).(func(context.Context, string) *types.Plugin); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Plugin)
		}
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, name)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, name)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// PluginInstall provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, name, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginInstallOptions) io.ReadCloser); ok {
		r0 = rf(ctx, name, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.PluginInstallOptions) error); ok {
		r1 = rf(ctx, name, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PluginList provides a mock function with given fields: ctx
func (_m *CommonAPIClient) PluginList(ctx context.Context) (types.PluginsListResponse, error) {
	ret := _m.Called(ctx)

	var r0 types.PluginsListResponse
	if rf, ok := ret.Get(0).(func(context.Context) types.PluginsListResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(types.PluginsListResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PluginPush provides a mock function with given fields: ctx, name, registryAuth
func (_m *CommonAPIClient) PluginPush(ctx context.Context, name string, registryAuth string) (io.ReadCloser, error) {
	ret := _m.Called(ctx, name, registryAuth)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, string) io.ReadCloser); ok {
		r0 = rf(ctx, name, registryAuth)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, name, registryAuth)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PluginRemove provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error {
	ret := _m.Called(ctx, name, options)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginRemoveOptions) error); ok {
		r0 = rf(ctx, name, options)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PluginSet provides a mock function with given fields: ctx, name, args
func (_m *CommonAPIClient) PluginSet(ctx context.Context, name string, args []string) error {
	ret := _m.Called(ctx, name, args)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) error); ok {
		r0 = rf(ctx, name, args)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PluginUpgrade provides a mock function with given fields: ctx, name, options
func (_m *CommonAPIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, name, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginInstallOptions) io.ReadCloser); ok {
		r0 = rf(ctx, name, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.PluginInstallOptions) error); ok {
		r1 = rf(ctx, name, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegistryLogin provides a mock function with given fields: ctx, auth
func (_m *CommonAPIClient) RegistryLogin(ctx context.Context, auth types.AuthConfig) (registry.AuthenticateOKBody, error) {
	ret := _m.Called(ctx, auth)

	var r0 registry.AuthenticateOKBody
	if rf, ok := ret.Get(0).(func(context.Context, types.AuthConfig) registry.AuthenticateOKBody); ok {
		r0 = rf(ctx, auth)
	} else {
		r0 = ret.Get(0).(registry.AuthenticateOKBody)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.AuthConfig) error); ok {
		r1 = rf(ctx, auth)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SecretCreate provides a mock function with given fields: ctx, secret
func (_m *CommonAPIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (types.SecretCreateResponse, error) {
	ret := _m.Called(ctx, secret)

	var r0 types.SecretCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, swarm.SecretSpec) types.SecretCreateResponse); ok {
		r0 = rf(ctx, secret)
	} else {
		r0 = ret.Get(0).(types.SecretCreateResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, swarm.SecretSpec) error); ok {
		r1 = rf(ctx, secret)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SecretInspectWithRaw provides a mock function with given fields: ctx, name
func (_m *CommonAPIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error) {
	ret := _m.Called(ctx, name)

	var r0 swarm.Secret
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Secret); ok {
		r0 = rf(ctx, name)
	} else {
		r0 = ret.Get(0).(swarm.Secret)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, name)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, name)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// SecretList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) SecretList(ctx context.Context, options types.SecretListOptions) ([]swarm.Secret, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Secret
	if rf, ok := ret.Get(0).(func(context.Context, types.SecretListOptions) []swarm.Secret); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Secret)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.SecretListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SecretRemove provides a mock function with given fields: ctx, id
func (_m *CommonAPIClient) SecretRemove(ctx context.Context, id string) error {
	ret := _m.Called(ctx, id)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SecretUpdate provides a mock function with given fields: ctx, id, version, secret
func (_m *CommonAPIClient) SecretUpdate(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error {
	ret := _m.Called(ctx, id, version, secret)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, swarm.Version, swarm.SecretSpec) error); ok {
		r0 = rf(ctx, id, version, secret)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ServerVersion provides a mock function with given fields: ctx
func (_m *CommonAPIClient) ServerVersion(ctx context.Context) (types.Version, error) {
	ret := _m.Called(ctx)

	var r0 types.Version
	if rf, ok := ret.Get(0).(func(context.Context) types.Version); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(types.Version)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ServiceCreate provides a mock function with given fields: ctx, service, options
func (_m *CommonAPIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error) {
	ret := _m.Called(ctx, service, options)

	var r0 types.ServiceCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, swarm.ServiceSpec, types.ServiceCreateOptions) types.ServiceCreateResponse); ok {
		r0 = rf(ctx, service, options)
	} else {
		r0 = ret.Get(0).(types.ServiceCreateResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, swarm.ServiceSpec, types.ServiceCreateOptions) error); ok {
		r1 = rf(ctx, service, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ServiceInspectWithRaw provides a mock function with given fields: ctx, serviceID
func (_m *CommonAPIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string) (swarm.Service, []byte, error) {
	ret := _m.Called(ctx, serviceID)

	var r0 swarm.Service
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Service); ok {
		r0 = rf(ctx, serviceID)
	} else {
		r0 = ret.Get(0).(swarm.Service)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, serviceID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, serviceID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ServiceList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) ServiceList(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Service
	if rf, ok := ret.Get(0).(func(context.Context, types.ServiceListOptions) []swarm.Service); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Service)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.ServiceListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ServiceLogs provides a mock function with given fields: ctx, serviceID, options
func (_m *CommonAPIClient) ServiceLogs(ctx context.Context, serviceID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, serviceID, options)

	var r0 io.ReadCloser
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerLogsOptions) io.ReadCloser); ok {
		r0 = rf(ctx, serviceID, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, types.ContainerLogsOptions) error); ok {
		r1 = rf(ctx, serviceID, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ServiceRemove provides a mock function with given fields: ctx, serviceID
func (_m *CommonAPIClient) ServiceRemove(ctx context.Context, serviceID string) error {
	ret := _m.Called(ctx, serviceID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, serviceID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ServiceUpdate provides a mock function with given fields: ctx, serviceID, version, service, options
func (_m *CommonAPIClient) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) (types.ServiceUpdateResponse, error) {
	ret := _m.Called(ctx, serviceID, version, service, options)

	var r0 types.ServiceUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, swarm.Version, swarm.ServiceSpec, types.ServiceUpdateOptions) types.ServiceUpdateResponse); ok {
		r0 = rf(ctx, serviceID, version, service, options)
	} else {
		r0 = ret.Get(0).(types.ServiceUpdateResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, swarm.Version, swarm.ServiceSpec, types.ServiceUpdateOptions) error); ok {
		r1 = rf(ctx, serviceID, version, service, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SwarmGetUnlockKey provides a mock function with given fields: ctx
func (_m *CommonAPIClient) SwarmGetUnlockKey(ctx context.Context) (types.SwarmUnlockKeyResponse, error) {
	ret := _m.Called(ctx)

	var r0 types.SwarmUnlockKeyResponse
	if rf, ok := ret.Get(0).(func(context.Context) types.SwarmUnlockKeyResponse); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(types.SwarmUnlockKeyResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SwarmInit provides a mock function with given fields: ctx, req
func (_m *CommonAPIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
	ret := _m.Called(ctx, req)

	var r0 string
	if rf, ok := ret.Get(0).(func(context.Context, swarm.InitRequest) string); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Get(0).(string)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, swarm.InitRequest) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SwarmInspect provides a mock function with given fields: ctx
func (_m *CommonAPIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
	ret := _m.Called(ctx)

	var r0 swarm.Swarm
	if rf, ok := ret.Get(0).(func(context.Context) swarm.Swarm); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(swarm.Swarm)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SwarmJoin provides a mock function with given fields: ctx, req
func (_m *CommonAPIClient) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error {
	ret := _m.Called(ctx, req)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.JoinRequest) error); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SwarmLeave provides a mock function with given fields: ctx, force
func (_m *CommonAPIClient) SwarmLeave(ctx context.Context, force bool) error {
	ret := _m.Called(ctx, force)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, bool) error); ok {
		r0 = rf(ctx, force)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SwarmUnlock provides a mock function with given fields: ctx, req
func (_m *CommonAPIClient) SwarmUnlock(ctx context.Context, req swarm.UnlockRequest) error {
	ret := _m.Called(ctx, req)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.UnlockRequest) error); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SwarmUpdate provides a mock function with given fields: ctx, version, _a2, flags
func (_m *CommonAPIClient) SwarmUpdate(ctx context.Context, version swarm.Version, _a2 swarm.Spec, flags swarm.UpdateFlags) error {
	ret := _m.Called(ctx, version, _a2, flags)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.Version, swarm.Spec, swarm.UpdateFlags) error); ok {
		r0 = rf(ctx, version, _a2, flags)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// TaskInspectWithRaw provides a mock function with given fields: ctx, taskID
func (_m *CommonAPIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
	ret := _m.Called(ctx, taskID)

	var r0 swarm.Task
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Task); ok {
		r0 = rf(ctx, taskID)
	} else {
		r0 = ret.Get(0).(swarm.Task)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, taskID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, taskID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// TaskList provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Task
	if rf, ok := ret.Get(0).(func(context.Context, types.TaskListOptions) []swarm.Task); ok {
		r0 = rf(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Task)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, types.TaskListOptions) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateClientVersion provides a mock function with given fields: v
func (_m *CommonAPIClient) UpdateClientVersion(v string) {
	_m.Called(v)
}

// VolumeCreate provides a mock function with given fields: ctx, options
func (_m *CommonAPIClient) VolumeCreate(ctx context.Context, options volume.VolumesCreateBody) (types.Volume, error) {
	ret := _m.Called(ctx, options)

	var r0 types.Volume
	if rf, ok := ret.Get(0).(func(context.Context, volume.VolumesCreateBody) types.Volume); ok {
		r0 = rf(ctx, options)
	} else {
		r0 = ret.Get(0).(types.Volume)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, volume.VolumesCreateBody) error); ok {
		r1 = rf(ctx, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// VolumeInspect provides a mock function with given fields: ctx, volumeID
func (_m *CommonAPIClient) VolumeInspect(ctx context.Context, volumeID string) (types.Volume, error) {
	ret := _m.Called(ctx, volumeID)

	var r0 types.Volume
	if rf, ok := ret.Get(0).(func(context.Context, string) types.Volume); ok {
		r0 = rf(ctx, volumeID)
	} else {
		r0 = ret.Get(0).(types.Volume)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, volumeID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// VolumeInspectWithRaw provides a mock function with given fields: ctx, volumeID
func (_m *CommonAPIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (types.Volume, []byte, error) {
	ret := _m.Called(ctx, volumeID)

	var r0 types.Volume
	if rf, ok := ret.Get(0).(func(context.Context, string) types.Volume); ok {
		r0 = rf(ctx, volumeID)
	} else {
		r0 = ret.Get(0).(types.Volume)
	}

	var r1 []byte
	if rf, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = rf(ctx, volumeID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = rf(ctx, volumeID)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// VolumeList provides a mock function with given fields: ctx, filter
func (_m *CommonAPIClient) VolumeList(ctx context.Context, filter filters.Args) (volume.VolumesListOKBody, error) {
	ret := _m.Called(ctx, filter)

	var r0 volume.VolumesListOKBody
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) volume.VolumesListOKBody); ok {
		r0 = rf(ctx, filter)
	} else {
		r0 = ret.Get(0).(volume.VolumesListOKBody)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = rf(ctx, filter)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// VolumeRemove provides a mock function with given fields: ctx, volumeID, force
func (_m *CommonAPIClient) VolumeRemove(ctx context.Context, volumeID string, force bool) error {
	ret := _m.Called(ctx, volumeID, force)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) error); ok {
		r0 = rf(ctx, volumeID, force)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// VolumesPrune provides a mock function with given fields: ctx, pruneFilter
func (_m *CommonAPIClient) VolumesPrune(ctx context.Context, pruneFilter filters.Args) (types.VolumesPruneReport, error) {
	ret := _m.Called(ctx, pruneFilter)

	var r0 types.VolumesPruneReport
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) types.VolumesPruneReport); ok {
		r0 = rf(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(types.VolumesPruneReport)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = rf(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}