github.com/projecteru2/core@v0.0.0-20240321043226-06bcc1c23f58/engine/docker/mocks/APIClient.go

// Code generated by mockery v2.31.4. DO NOT EDIT.

package mocks

import (
	context "context"

	container "github.com/docker/docker/api/types/container"

	events "github.com/docker/docker/api/types/events"

	filters "github.com/docker/docker/api/types/filters"

	http "net/http"

	image "github.com/docker/docker/api/types/image"

	io "io"

	mock "github.com/stretchr/testify/mock"

	net "net"

	network "github.com/docker/docker/api/types/network"

	registry "github.com/docker/docker/api/types/registry"

	swarm "github.com/docker/docker/api/types/swarm"

	types "github.com/docker/docker/api/types"

	v1 "github.com/opencontainers/image-spec/specs-go/v1"

	volume "github.com/docker/docker/api/types/volume"
)

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

// BuildCachePrune provides a mock function with given fields: ctx, opts
func (_m *APIClient) BuildCachePrune(ctx context.Context, opts types.BuildCachePruneOptions) (*types.BuildCachePruneReport, error) {
	ret := _m.Called(ctx, opts)

	var r0 *types.BuildCachePruneReport
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.BuildCachePruneOptions) (*types.BuildCachePruneReport, error)); ok {
		return rf(ctx, opts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.BuildCachePruneOptions) *types.BuildCachePruneReport); ok {
		r0 = rf(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.BuildCachePruneReport)
		}
	}

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

	return r0, r1
}

// BuildCancel provides a mock function with given fields: ctx, id
func (_m *APIClient) BuildCancel(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
}

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

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

	return r0
}

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

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

	return r0
}

// CheckpointList provides a mock function with given fields: ctx, _a1, options
func (_m *APIClient) CheckpointList(ctx context.Context, _a1 string, options types.CheckpointListOptions) ([]types.Checkpoint, error) {
	ret := _m.Called(ctx, _a1, options)

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

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

	return r0, r1
}

// ClientVersion provides a mock function with given fields:
func (_m *APIClient) 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
}

// Close provides a mock function with given fields:
func (_m *APIClient) Close() error {
	ret := _m.Called()

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

	return r0
}

// ConfigCreate provides a mock function with given fields: ctx, config
func (_m *APIClient) ConfigCreate(ctx context.Context, config swarm.ConfigSpec) (types.ConfigCreateResponse, error) {
	ret := _m.Called(ctx, config)

	var r0 types.ConfigCreateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.ConfigSpec) (types.ConfigCreateResponse, error)); ok {
		return rf(ctx, config)
	}
	if rf, ok := ret.Get(0).(func(context.Context, swarm.ConfigSpec) types.ConfigCreateResponse); ok {
		r0 = rf(ctx, config)
	} else {
		r0 = ret.Get(0).(types.ConfigCreateResponse)
	}

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

	return r0, r1
}

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

	var r0 swarm.Config
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (swarm.Config, []byte, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Config); ok {
		r0 = rf(ctx, name)
	} else {
		r0 = ret.Get(0).(swarm.Config)
	}

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

	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
}

// ConfigList provides a mock function with given fields: ctx, options
func (_m *APIClient) ConfigList(ctx context.Context, options types.ConfigListOptions) ([]swarm.Config, error) {
	ret := _m.Called(ctx, options)

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

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

	return r0, r1
}

// ConfigRemove provides a mock function with given fields: ctx, id
func (_m *APIClient) ConfigRemove(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
}

// ConfigUpdate provides a mock function with given fields: ctx, id, version, config
func (_m *APIClient) ConfigUpdate(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error {
	ret := _m.Called(ctx, id, version, config)

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

	return r0
}

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

	var r0 types.HijackedResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerAttachOptions) (types.HijackedResponse, error)); ok {
		return rf(ctx, _a1, options)
	}
	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)
	}

	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 *APIClient) ContainerCommit(ctx context.Context, _a1 string, options types.ContainerCommitOptions) (types.IDResponse, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 types.IDResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerCommitOptions) (types.IDResponse, error)); ok {
		return rf(ctx, _a1, options)
	}
	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)
	}

	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, platform, containerName
func (_m *APIClient) ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *v1.Platform, containerName string) (container.CreateResponse, error) {
	ret := _m.Called(ctx, config, hostConfig, networkingConfig, platform, containerName)

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

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

	return r0, r1
}

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

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

	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 *APIClient) ContainerExecAttach(ctx context.Context, execID string, config types.ExecStartCheck) (types.HijackedResponse, error) {
	ret := _m.Called(ctx, execID, config)

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

	if rf, ok := ret.Get(1).(func(context.Context, string, types.ExecStartCheck) 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 *APIClient) ContainerExecCreate(ctx context.Context, _a1 string, config types.ExecConfig) (types.IDResponse, error) {
	ret := _m.Called(ctx, _a1, config)

	var r0 types.IDResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ExecConfig) (types.IDResponse, error)); ok {
		return rf(ctx, _a1, config)
	}
	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)
	}

	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 *APIClient) ContainerExecInspect(ctx context.Context, execID string) (types.ContainerExecInspect, error) {
	ret := _m.Called(ctx, execID)

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

	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 *APIClient) 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 *APIClient) 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 *APIClient) ContainerExport(ctx context.Context, _a1 string) (io.ReadCloser, error) {
	ret := _m.Called(ctx, _a1)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (io.ReadCloser, error)); ok {
		return rf(ctx, _a1)
	}
	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)
		}
	}

	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 *APIClient) ContainerInspect(ctx context.Context, _a1 string) (types.ContainerJSON, error) {
	ret := _m.Called(ctx, _a1)

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

	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 *APIClient) ContainerInspectWithRaw(ctx context.Context, _a1 string, getSize bool) (types.ContainerJSON, []byte, error) {
	ret := _m.Called(ctx, _a1, getSize)

	var r0 types.ContainerJSON
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) (types.ContainerJSON, []byte, error)); ok {
		return rf(ctx, _a1, getSize)
	}
	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)
	}

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

	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 *APIClient) 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 *APIClient) ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error) {
	ret := _m.Called(ctx, options)

	var r0 []types.Container
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.ContainerListOptions) ([]types.Container, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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 *APIClient) ContainerLogs(ctx context.Context, _a1 string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, _a1, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerLogsOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, _a1, options)
	}
	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)
		}
	}

	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 *APIClient) 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 *APIClient) 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 *APIClient) 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 *APIClient) 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, options
func (_m *APIClient) ContainerRestart(ctx context.Context, _a1 string, options container.StopOptions) error {
	ret := _m.Called(ctx, _a1, options)

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

	return r0
}

// ContainerStart provides a mock function with given fields: ctx, _a1, options
func (_m *APIClient) 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 *APIClient) ContainerStatPath(ctx context.Context, _a1 string, path string) (types.ContainerPathStat, error) {
	ret := _m.Called(ctx, _a1, path)

	var r0 types.ContainerPathStat
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (types.ContainerPathStat, error)); ok {
		return rf(ctx, _a1, path)
	}
	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)
	}

	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 *APIClient) ContainerStats(ctx context.Context, _a1 string, stream bool) (types.ContainerStats, error) {
	ret := _m.Called(ctx, _a1, stream)

	var r0 types.ContainerStats
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, bool) (types.ContainerStats, error)); ok {
		return rf(ctx, _a1, stream)
	}
	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)
	}

	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
}

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

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

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

	return r0, r1
}

// ContainerStop provides a mock function with given fields: ctx, _a1, options
func (_m *APIClient) ContainerStop(ctx context.Context, _a1 string, options container.StopOptions) error {
	ret := _m.Called(ctx, _a1, options)

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

	return r0
}

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

	var r0 container.ContainerTopOKBody
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) (container.ContainerTopOKBody, error)); ok {
		return rf(ctx, _a1, arguments)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) container.ContainerTopOKBody); ok {
		r0 = rf(ctx, _a1, arguments)
	} else {
		r0 = ret.Get(0).(container.ContainerTopOKBody)
	}

	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 *APIClient) 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 *APIClient) ContainerUpdate(ctx context.Context, _a1 string, updateConfig container.UpdateConfig) (container.ContainerUpdateOKBody, error) {
	ret := _m.Called(ctx, _a1, updateConfig)

	var r0 container.ContainerUpdateOKBody
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, container.UpdateConfig) (container.ContainerUpdateOKBody, error)); ok {
		return rf(ctx, _a1, updateConfig)
	}
	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)
	}

	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, condition
func (_m *APIClient) ContainerWait(ctx context.Context, _a1 string, condition container.WaitCondition) (<-chan container.WaitResponse, <-chan error) {
	ret := _m.Called(ctx, _a1, condition)

	var r0 <-chan container.WaitResponse
	var r1 <-chan error
	if rf, ok := ret.Get(0).(func(context.Context, string, container.WaitCondition) (<-chan container.WaitResponse, <-chan error)); ok {
		return rf(ctx, _a1, condition)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, container.WaitCondition) <-chan container.WaitResponse); ok {
		r0 = rf(ctx, _a1, condition)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan container.WaitResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, container.WaitCondition) <-chan error); ok {
		r1 = rf(ctx, _a1, condition)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(<-chan error)
		}
	}

	return r0, r1
}

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

	var r0 types.ContainersPruneReport
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) (types.ContainersPruneReport, error)); ok {
		return rf(ctx, pruneFilters)
	}
	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)
	}

	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 *APIClient) CopyFromContainer(ctx context.Context, _a1 string, srcPath string) (io.ReadCloser, types.ContainerPathStat, error) {
	ret := _m.Called(ctx, _a1, srcPath)

	var r0 io.ReadCloser
	var r1 types.ContainerPathStat
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (io.ReadCloser, types.ContainerPathStat, error)); ok {
		return rf(ctx, _a1, srcPath)
	}
	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)
		}
	}

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

	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 *APIClient) 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
}

// DaemonHost provides a mock function with given fields:
func (_m *APIClient) DaemonHost() 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
}

// DialHijack provides a mock function with given fields: ctx, url, proto, meta
func (_m *APIClient) DialHijack(ctx context.Context, url string, proto string, meta map[string][]string) (net.Conn, error) {
	ret := _m.Called(ctx, url, proto, meta)

	var r0 net.Conn
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, map[string][]string) (net.Conn, error)); ok {
		return rf(ctx, url, proto, meta)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, map[string][]string) net.Conn); ok {
		r0 = rf(ctx, url, proto, meta)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(net.Conn)
		}
	}

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

	return r0, r1
}

// Dialer provides a mock function with given fields:
func (_m *APIClient) Dialer() func(context.Context) (net.Conn, error) {
	ret := _m.Called()

	var r0 func(context.Context) (net.Conn, error)
	if rf, ok := ret.Get(0).(func() func(context.Context) (net.Conn, error)); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(func(context.Context) (net.Conn, error))
		}
	}

	return r0
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 <-chan events.Message
	var r1 <-chan error
	if rf, ok := ret.Get(0).(func(context.Context, types.EventsOptions) (<-chan events.Message, <-chan error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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
}

// HTTPClient provides a mock function with given fields:
func (_m *APIClient) HTTPClient() *http.Client {
	ret := _m.Called()

	var r0 *http.Client
	if rf, ok := ret.Get(0).(func() *http.Client); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Client)
		}
	}

	return r0
}

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

	var r0 types.ImageBuildResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, types.ImageBuildOptions) (types.ImageBuildResponse, error)); ok {
		return rf(ctx, _a1, options)
	}
	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)
	}

	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 *APIClient) ImageCreate(ctx context.Context, parentReference string, options types.ImageCreateOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, parentReference, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImageCreateOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, parentReference, options)
	}
	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)
		}
	}

	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, _a1
func (_m *APIClient) ImageHistory(ctx context.Context, _a1 string) ([]image.HistoryResponseItem, error) {
	ret := _m.Called(ctx, _a1)

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

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

	return r0, r1
}

// ImageImport provides a mock function with given fields: ctx, source, ref, options
func (_m *APIClient) 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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.ImageImportSource, string, types.ImageImportOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, source, ref, options)
	}
	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)
		}
	}

	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, _a1
func (_m *APIClient) ImageInspectWithRaw(ctx context.Context, _a1 string) (types.ImageInspect, []byte, error) {
	ret := _m.Called(ctx, _a1)

	var r0 types.ImageInspect
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (types.ImageInspect, []byte, error)); ok {
		return rf(ctx, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) types.ImageInspect); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Get(0).(types.ImageInspect)
	}

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

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

	return r0, r1, r2
}

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

	var r0 []types.ImageSummary
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.ImageListOptions) ([]types.ImageSummary, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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 *APIClient) ImageLoad(ctx context.Context, input io.Reader, quiet bool) (types.ImageLoadResponse, error) {
	ret := _m.Called(ctx, input, quiet)

	var r0 types.ImageLoadResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, io.Reader, bool) (types.ImageLoadResponse, error)); ok {
		return rf(ctx, input, quiet)
	}
	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)
	}

	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 *APIClient) ImagePull(ctx context.Context, ref string, options types.ImagePullOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, ref, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImagePullOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, ref, options)
	}
	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)
		}
	}

	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 *APIClient) ImagePush(ctx context.Context, ref string, options types.ImagePushOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, ref, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImagePushOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, ref, options)
	}
	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)
		}
	}

	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, _a1, options
func (_m *APIClient) ImageRemove(ctx context.Context, _a1 string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error) {
	ret := _m.Called(ctx, _a1, options)

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

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

	return r0, r1
}

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

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []string) (io.ReadCloser, error)); ok {
		return rf(ctx, images)
	}
	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)
		}
	}

	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 *APIClient) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) {
	ret := _m.Called(ctx, term, options)

	var r0 []registry.SearchResult
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ImageSearchOptions) ([]registry.SearchResult, error)); ok {
		return rf(ctx, term, options)
	}
	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)
		}
	}

	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, _a1, ref
func (_m *APIClient) ImageTag(ctx context.Context, _a1 string, ref string) error {
	ret := _m.Called(ctx, _a1, ref)

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

	return r0
}

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

	var r0 types.ImagesPruneReport
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) (types.ImagesPruneReport, error)); ok {
		return rf(ctx, pruneFilter)
	}
	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)
	}

	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 *APIClient) Info(ctx context.Context) (types.Info, error) {
	ret := _m.Called(ctx)

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

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

	return r0, r1
}

// NegotiateAPIVersion provides a mock function with given fields: ctx
func (_m *APIClient) NegotiateAPIVersion(ctx context.Context) {
	_m.Called(ctx)
}

// NegotiateAPIVersionPing provides a mock function with given fields: _a0
func (_m *APIClient) NegotiateAPIVersionPing(_a0 types.Ping) {
	_m.Called(_a0)
}

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

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

	return r0
}

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

	var r0 types.NetworkCreateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.NetworkCreate) (types.NetworkCreateResponse, error)); ok {
		return rf(ctx, name, options)
	}
	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)
	}

	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, _a1, _a2, force
func (_m *APIClient) NetworkDisconnect(ctx context.Context, _a1 string, _a2 string, force bool) error {
	ret := _m.Called(ctx, _a1, _a2, force)

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 types.NetworkResource
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.NetworkInspectOptions) (types.NetworkResource, []byte, error)); ok {
		return rf(ctx, _a1, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, types.NetworkInspectOptions) types.NetworkResource); ok {
		r0 = rf(ctx, _a1, options)
	} else {
		r0 = ret.Get(0).(types.NetworkResource)
	}

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

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

	return r0, r1, r2
}

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

	var r0 []types.NetworkResource
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.NetworkListOptions) ([]types.NetworkResource, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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, _a1
func (_m *APIClient) NetworkRemove(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
}

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

	var r0 types.NetworksPruneReport
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) (types.NetworksPruneReport, error)); ok {
		return rf(ctx, pruneFilter)
	}
	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)
	}

	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 *APIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
	ret := _m.Called(ctx, nodeID)

	var r0 swarm.Node
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (swarm.Node, []byte, error)); ok {
		return rf(ctx, nodeID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Node); ok {
		r0 = rf(ctx, nodeID)
	} else {
		r0 = ret.Get(0).(swarm.Node)
	}

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

	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 *APIClient) NodeList(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Node
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.NodeListOptions) ([]swarm.Node, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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 *APIClient) 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 *APIClient) 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 *APIClient) Ping(ctx context.Context) (types.Ping, error) {
	ret := _m.Called(ctx)

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

	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 *APIClient) 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 *APIClient) 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 *APIClient) 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 *APIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
	ret := _m.Called(ctx, name)

	var r0 *types.Plugin
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*types.Plugin, []byte, error)); ok {
		return rf(ctx, name)
	}
	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)
		}
	}

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

	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 *APIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, name, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginInstallOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, name, options)
	}
	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)
		}
	}

	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, filter
func (_m *APIClient) PluginList(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error) {
	ret := _m.Called(ctx, filter)

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

	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
}

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

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (io.ReadCloser, error)); ok {
		return rf(ctx, name, registryAuth)
	}
	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)
		}
	}

	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 *APIClient) 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 *APIClient) 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 *APIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, name, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.PluginInstallOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, name, options)
	}
	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)
		}
	}

	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 *APIClient) RegistryLogin(ctx context.Context, auth types.AuthConfig) (registry.AuthenticateOKBody, error) {
	ret := _m.Called(ctx, auth)

	var r0 registry.AuthenticateOKBody
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.AuthConfig) (registry.AuthenticateOKBody, error)); ok {
		return rf(ctx, auth)
	}
	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)
	}

	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 *APIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (types.SecretCreateResponse, error) {
	ret := _m.Called(ctx, secret)

	var r0 types.SecretCreateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.SecretSpec) (types.SecretCreateResponse, error)); ok {
		return rf(ctx, secret)
	}
	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)
	}

	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 *APIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error) {
	ret := _m.Called(ctx, name)

	var r0 swarm.Secret
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (swarm.Secret, []byte, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Secret); ok {
		r0 = rf(ctx, name)
	} else {
		r0 = ret.Get(0).(swarm.Secret)
	}

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

	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 *APIClient) SecretList(ctx context.Context, options types.SecretListOptions) ([]swarm.Secret, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Secret
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.SecretListOptions) ([]swarm.Secret, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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 *APIClient) 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 *APIClient) 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 *APIClient) ServerVersion(ctx context.Context) (types.Version, error) {
	ret := _m.Called(ctx)

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

	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 *APIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options types.ServiceCreateOptions) (types.ServiceCreateResponse, error) {
	ret := _m.Called(ctx, service, options)

	var r0 types.ServiceCreateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, swarm.ServiceSpec, types.ServiceCreateOptions) (types.ServiceCreateResponse, error)); ok {
		return rf(ctx, service, options)
	}
	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)
	}

	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, options
func (_m *APIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string, options types.ServiceInspectOptions) (swarm.Service, []byte, error) {
	ret := _m.Called(ctx, serviceID, options)

	var r0 swarm.Service
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ServiceInspectOptions) (swarm.Service, []byte, error)); ok {
		return rf(ctx, serviceID, options)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ServiceInspectOptions) swarm.Service); ok {
		r0 = rf(ctx, serviceID, options)
	} else {
		r0 = ret.Get(0).(swarm.Service)
	}

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

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

	return r0, r1, r2
}

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

	var r0 []swarm.Service
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.ServiceListOptions) ([]swarm.Service, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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 *APIClient) ServiceLogs(ctx context.Context, serviceID string, options types.ContainerLogsOptions) (io.ReadCloser, error) {
	ret := _m.Called(ctx, serviceID, options)

	var r0 io.ReadCloser
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, types.ContainerLogsOptions) (io.ReadCloser, error)); ok {
		return rf(ctx, serviceID, options)
	}
	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)
		}
	}

	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 *APIClient) 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 *APIClient) 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
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, swarm.Version, swarm.ServiceSpec, types.ServiceUpdateOptions) (types.ServiceUpdateResponse, error)); ok {
		return rf(ctx, serviceID, version, service, options)
	}
	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)
	}

	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 *APIClient) SwarmGetUnlockKey(ctx context.Context) (types.SwarmUnlockKeyResponse, error) {
	ret := _m.Called(ctx)

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

	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 *APIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
	ret := _m.Called(ctx, req)

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

	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 *APIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
	ret := _m.Called(ctx)

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

	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 *APIClient) 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 *APIClient) 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 *APIClient) 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 *APIClient) 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 *APIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
	ret := _m.Called(ctx, taskID)

	var r0 swarm.Task
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (swarm.Task, []byte, error)); ok {
		return rf(ctx, taskID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) swarm.Task); ok {
		r0 = rf(ctx, taskID)
	} else {
		r0 = ret.Get(0).(swarm.Task)
	}

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

	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 *APIClient) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
	ret := _m.Called(ctx, options)

	var r0 []swarm.Task
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.TaskListOptions) ([]swarm.Task, error)); ok {
		return rf(ctx, options)
	}
	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)
		}
	}

	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
}

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

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

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

	return r0, r1
}

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

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

	if rf, ok := ret.Get(1).(func(context.Context, volume.CreateOptions) 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 *APIClient) VolumeInspect(ctx context.Context, volumeID string) (volume.Volume, error) {
	ret := _m.Called(ctx, volumeID)

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

	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 *APIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (volume.Volume, []byte, error) {
	ret := _m.Called(ctx, volumeID)

	var r0 volume.Volume
	var r1 []byte
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (volume.Volume, []byte, error)); ok {
		return rf(ctx, volumeID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) volume.Volume); ok {
		r0 = rf(ctx, volumeID)
	} else {
		r0 = ret.Get(0).(volume.Volume)
	}

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

	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 *APIClient) VolumeList(ctx context.Context, filter filters.Args) (volume.ListResponse, error) {
	ret := _m.Called(ctx, filter)

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

	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 *APIClient) 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
}

// VolumeUpdate provides a mock function with given fields: ctx, volumeID, version, options
func (_m *APIClient) VolumeUpdate(ctx context.Context, volumeID string, version swarm.Version, options volume.UpdateOptions) error {
	ret := _m.Called(ctx, volumeID, version, options)

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

	return r0
}

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

	var r0 types.VolumesPruneReport
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, filters.Args) (types.VolumesPruneReport, error)); ok {
		return rf(ctx, pruneFilter)
	}
	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)
	}

	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
}

// NewAPIClient creates a new instance of APIClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewAPIClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *APIClient {
	mock := &APIClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}