// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package docker

import (
	"context"
	"io"
	"net"
	"net/http"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/build"
	"github.com/docker/docker/api/types/checkpoint"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/api/types/events"
	"github.com/docker/docker/api/types/filters"
	"github.com/docker/docker/api/types/image"
	"github.com/docker/docker/api/types/network"
	"github.com/docker/docker/api/types/registry"
	"github.com/docker/docker/api/types/swarm"
	"github.com/docker/docker/api/types/system"
	"github.com/docker/docker/api/types/volume"
	"github.com/docker/docker/client"
	"github.com/opencontainers/image-spec/specs-go/v1"
	mock "github.com/stretchr/testify/mock"
)

// NewMockAPIClient creates a new instance of MockAPIClient. 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 NewMockAPIClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAPIClient {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockAPIClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

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

type MockAPIClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAPIClient) EXPECT() *MockAPIClient_Expecter {
	return &MockAPIClient_Expecter{mock: &_m.Mock}
}

// BuildCachePrune provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) BuildCachePrune(ctx context.Context, opts build.CachePruneOptions) (*build.CachePruneReport, error) {
	ret := _mock.Called(ctx, opts)

	if len(ret) == 0 {
		panic("no return value specified for BuildCachePrune")
	}

	var r0 *build.CachePruneReport
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, build.CachePruneOptions) (*build.CachePruneReport, error)); ok {
		return returnFunc(ctx, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, build.CachePruneOptions) *build.CachePruneReport); ok {
		r0 = returnFunc(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*build.CachePruneReport)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, build.CachePruneOptions) error); ok {
		r1 = returnFunc(ctx, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_BuildCachePrune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildCachePrune'
type MockAPIClient_BuildCachePrune_Call struct {
	*mock.Call
}

// BuildCachePrune is a helper method to define mock.On call
//   - ctx context.Context
//   - opts build.CachePruneOptions
func (_e *MockAPIClient_Expecter) BuildCachePrune(ctx any, opts any) *MockAPIClient_BuildCachePrune_Call {
	return &MockAPIClient_BuildCachePrune_Call{Call: _e.mock.On("BuildCachePrune", ctx, opts)}
}

func (_c *MockAPIClient_BuildCachePrune_Call) Run(run func(ctx context.Context, opts build.CachePruneOptions)) *MockAPIClient_BuildCachePrune_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 build.CachePruneOptions
		if args[1] != nil {
			arg1 = args[1].(build.CachePruneOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_BuildCachePrune_Call) Return(cachePruneReport *build.CachePruneReport, err error) *MockAPIClient_BuildCachePrune_Call {
	_c.Call.Return(cachePruneReport, err)
	return _c
}

func (_c *MockAPIClient_BuildCachePrune_Call) RunAndReturn(run func(ctx context.Context, opts build.CachePruneOptions) (*build.CachePruneReport, error)) *MockAPIClient_BuildCachePrune_Call {
	_c.Call.Return(run)
	return _c
}

// BuildCancel provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) BuildCancel(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for BuildCancel")
	}

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

// MockAPIClient_BuildCancel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BuildCancel'
type MockAPIClient_BuildCancel_Call struct {
	*mock.Call
}

// BuildCancel is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockAPIClient_Expecter) BuildCancel(ctx any, id any) *MockAPIClient_BuildCancel_Call {
	return &MockAPIClient_BuildCancel_Call{Call: _e.mock.On("BuildCancel", ctx, id)}
}

func (_c *MockAPIClient_BuildCancel_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_BuildCancel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_BuildCancel_Call) Return(err error) *MockAPIClient_BuildCancel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_BuildCancel_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_BuildCancel_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) CheckpointCreate(ctx context.Context, container string, options checkpoint.CreateOptions) error {
	ret := _mock.Called(ctx, container, options)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointCreate")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, checkpoint.CreateOptions) error); ok {
		r0 = returnFunc(ctx, container, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_CheckpointCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointCreate'
type MockAPIClient_CheckpointCreate_Call struct {
	*mock.Call
}

// CheckpointCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - container string
//   - options checkpoint.CreateOptions
func (_e *MockAPIClient_Expecter) CheckpointCreate(ctx any, container any, options any) *MockAPIClient_CheckpointCreate_Call {
	return &MockAPIClient_CheckpointCreate_Call{Call: _e.mock.On("CheckpointCreate", ctx, container, options)}
}

func (_c *MockAPIClient_CheckpointCreate_Call) Run(run func(ctx context.Context, container string, options checkpoint.CreateOptions)) *MockAPIClient_CheckpointCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 checkpoint.CreateOptions
		if args[2] != nil {
			arg2 = args[2].(checkpoint.CreateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_CheckpointCreate_Call) Return(err error) *MockAPIClient_CheckpointCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_CheckpointCreate_Call) RunAndReturn(run func(ctx context.Context, container string, options checkpoint.CreateOptions) error) *MockAPIClient_CheckpointCreate_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointDelete provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) CheckpointDelete(ctx context.Context, container string, options checkpoint.DeleteOptions) error {
	ret := _mock.Called(ctx, container, options)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointDelete")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, checkpoint.DeleteOptions) error); ok {
		r0 = returnFunc(ctx, container, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_CheckpointDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointDelete'
type MockAPIClient_CheckpointDelete_Call struct {
	*mock.Call
}

// CheckpointDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - container string
//   - options checkpoint.DeleteOptions
func (_e *MockAPIClient_Expecter) CheckpointDelete(ctx any, container any, options any) *MockAPIClient_CheckpointDelete_Call {
	return &MockAPIClient_CheckpointDelete_Call{Call: _e.mock.On("CheckpointDelete", ctx, container, options)}
}

func (_c *MockAPIClient_CheckpointDelete_Call) Run(run func(ctx context.Context, container string, options checkpoint.DeleteOptions)) *MockAPIClient_CheckpointDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 checkpoint.DeleteOptions
		if args[2] != nil {
			arg2 = args[2].(checkpoint.DeleteOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_CheckpointDelete_Call) Return(err error) *MockAPIClient_CheckpointDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_CheckpointDelete_Call) RunAndReturn(run func(ctx context.Context, container string, options checkpoint.DeleteOptions) error) *MockAPIClient_CheckpointDelete_Call {
	_c.Call.Return(run)
	return _c
}

// CheckpointList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) CheckpointList(ctx context.Context, container string, options checkpoint.ListOptions) ([]checkpoint.Summary, error) {
	ret := _mock.Called(ctx, container, options)

	if len(ret) == 0 {
		panic("no return value specified for CheckpointList")
	}

	var r0 []checkpoint.Summary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, checkpoint.ListOptions) ([]checkpoint.Summary, error)); ok {
		return returnFunc(ctx, container, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, checkpoint.ListOptions) []checkpoint.Summary); ok {
		r0 = returnFunc(ctx, container, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]checkpoint.Summary)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, checkpoint.ListOptions) error); ok {
		r1 = returnFunc(ctx, container, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_CheckpointList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckpointList'
type MockAPIClient_CheckpointList_Call struct {
	*mock.Call
}

// CheckpointList is a helper method to define mock.On call
//   - ctx context.Context
//   - container string
//   - options checkpoint.ListOptions
func (_e *MockAPIClient_Expecter) CheckpointList(ctx any, container any, options any) *MockAPIClient_CheckpointList_Call {
	return &MockAPIClient_CheckpointList_Call{Call: _e.mock.On("CheckpointList", ctx, container, options)}
}

func (_c *MockAPIClient_CheckpointList_Call) Run(run func(ctx context.Context, container string, options checkpoint.ListOptions)) *MockAPIClient_CheckpointList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 checkpoint.ListOptions
		if args[2] != nil {
			arg2 = args[2].(checkpoint.ListOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_CheckpointList_Call) Return(summarys []checkpoint.Summary, err error) *MockAPIClient_CheckpointList_Call {
	_c.Call.Return(summarys, err)
	return _c
}

func (_c *MockAPIClient_CheckpointList_Call) RunAndReturn(run func(ctx context.Context, container string, options checkpoint.ListOptions) ([]checkpoint.Summary, error)) *MockAPIClient_CheckpointList_Call {
	_c.Call.Return(run)
	return _c
}

// ClientVersion provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ClientVersion() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ClientVersion")
	}

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

// MockAPIClient_ClientVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersion'
type MockAPIClient_ClientVersion_Call struct {
	*mock.Call
}

// ClientVersion is a helper method to define mock.On call
func (_e *MockAPIClient_Expecter) ClientVersion() *MockAPIClient_ClientVersion_Call {
	return &MockAPIClient_ClientVersion_Call{Call: _e.mock.On("ClientVersion")}
}

func (_c *MockAPIClient_ClientVersion_Call) Run(run func()) *MockAPIClient_ClientVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockAPIClient_ClientVersion_Call) Return(s string) *MockAPIClient_ClientVersion_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockAPIClient_ClientVersion_Call) RunAndReturn(run func() string) *MockAPIClient_ClientVersion_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) Close() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

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

// MockAPIClient_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockAPIClient_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockAPIClient_Expecter) Close() *MockAPIClient_Close_Call {
	return &MockAPIClient_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockAPIClient_Close_Call) Run(run func()) *MockAPIClient_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockAPIClient_Close_Call) Return(err error) *MockAPIClient_Close_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_Close_Call) RunAndReturn(run func() error) *MockAPIClient_Close_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ConfigCreate(ctx context.Context, config swarm.ConfigSpec) (swarm.ConfigCreateResponse, error) {
	ret := _mock.Called(ctx, config)

	if len(ret) == 0 {
		panic("no return value specified for ConfigCreate")
	}

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

// MockAPIClient_ConfigCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigCreate'
type MockAPIClient_ConfigCreate_Call struct {
	*mock.Call
}

// ConfigCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - config swarm.ConfigSpec
func (_e *MockAPIClient_Expecter) ConfigCreate(ctx any, config any) *MockAPIClient_ConfigCreate_Call {
	return &MockAPIClient_ConfigCreate_Call{Call: _e.mock.On("ConfigCreate", ctx, config)}
}

func (_c *MockAPIClient_ConfigCreate_Call) Run(run func(ctx context.Context, config swarm.ConfigSpec)) *MockAPIClient_ConfigCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.ConfigSpec
		if args[1] != nil {
			arg1 = args[1].(swarm.ConfigSpec)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ConfigCreate_Call) Return(configCreateResponse swarm.ConfigCreateResponse, err error) *MockAPIClient_ConfigCreate_Call {
	_c.Call.Return(configCreateResponse, err)
	return _c
}

func (_c *MockAPIClient_ConfigCreate_Call) RunAndReturn(run func(ctx context.Context, config swarm.ConfigSpec) (swarm.ConfigCreateResponse, error)) *MockAPIClient_ConfigCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ConfigInspectWithRaw(ctx context.Context, name string) (swarm.Config, []byte, error) {
	ret := _mock.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for ConfigInspectWithRaw")
	}

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

// MockAPIClient_ConfigInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigInspectWithRaw'
type MockAPIClient_ConfigInspectWithRaw_Call struct {
	*mock.Call
}

// ConfigInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockAPIClient_Expecter) ConfigInspectWithRaw(ctx any, name any) *MockAPIClient_ConfigInspectWithRaw_Call {
	return &MockAPIClient_ConfigInspectWithRaw_Call{Call: _e.mock.On("ConfigInspectWithRaw", ctx, name)}
}

func (_c *MockAPIClient_ConfigInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_ConfigInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ConfigInspectWithRaw_Call) Return(config swarm.Config, bytes []byte, err error) *MockAPIClient_ConfigInspectWithRaw_Call {
	_c.Call.Return(config, bytes, err)
	return _c
}

func (_c *MockAPIClient_ConfigInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (swarm.Config, []byte, error)) *MockAPIClient_ConfigInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ConfigList(ctx context.Context, options swarm.ConfigListOptions) ([]swarm.Config, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for ConfigList")
	}

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

// MockAPIClient_ConfigList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigList'
type MockAPIClient_ConfigList_Call struct {
	*mock.Call
}

// ConfigList is a helper method to define mock.On call
//   - ctx context.Context
//   - options swarm.ConfigListOptions
func (_e *MockAPIClient_Expecter) ConfigList(ctx any, options any) *MockAPIClient_ConfigList_Call {
	return &MockAPIClient_ConfigList_Call{Call: _e.mock.On("ConfigList", ctx, options)}
}

func (_c *MockAPIClient_ConfigList_Call) Run(run func(ctx context.Context, options swarm.ConfigListOptions)) *MockAPIClient_ConfigList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.ConfigListOptions
		if args[1] != nil {
			arg1 = args[1].(swarm.ConfigListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ConfigList_Call) Return(configs []swarm.Config, err error) *MockAPIClient_ConfigList_Call {
	_c.Call.Return(configs, err)
	return _c
}

func (_c *MockAPIClient_ConfigList_Call) RunAndReturn(run func(ctx context.Context, options swarm.ConfigListOptions) ([]swarm.Config, error)) *MockAPIClient_ConfigList_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ConfigRemove(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for ConfigRemove")
	}

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

// MockAPIClient_ConfigRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigRemove'
type MockAPIClient_ConfigRemove_Call struct {
	*mock.Call
}

// ConfigRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockAPIClient_Expecter) ConfigRemove(ctx any, id any) *MockAPIClient_ConfigRemove_Call {
	return &MockAPIClient_ConfigRemove_Call{Call: _e.mock.On("ConfigRemove", ctx, id)}
}

func (_c *MockAPIClient_ConfigRemove_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_ConfigRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ConfigRemove_Call) Return(err error) *MockAPIClient_ConfigRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ConfigRemove_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_ConfigRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ConfigUpdate(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error {
	ret := _mock.Called(ctx, id, version, config)

	if len(ret) == 0 {
		panic("no return value specified for ConfigUpdate")
	}

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

// MockAPIClient_ConfigUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigUpdate'
type MockAPIClient_ConfigUpdate_Call struct {
	*mock.Call
}

// ConfigUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - version swarm.Version
//   - config swarm.ConfigSpec
func (_e *MockAPIClient_Expecter) ConfigUpdate(ctx any, id any, version any, config any) *MockAPIClient_ConfigUpdate_Call {
	return &MockAPIClient_ConfigUpdate_Call{Call: _e.mock.On("ConfigUpdate", ctx, id, version, config)}
}

func (_c *MockAPIClient_ConfigUpdate_Call) Run(run func(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec)) *MockAPIClient_ConfigUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.Version
		if args[2] != nil {
			arg2 = args[2].(swarm.Version)
		}
		var arg3 swarm.ConfigSpec
		if args[3] != nil {
			arg3 = args[3].(swarm.ConfigSpec)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_ConfigUpdate_Call) Return(err error) *MockAPIClient_ConfigUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ConfigUpdate_Call) RunAndReturn(run func(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error) *MockAPIClient_ConfigUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerAttach provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerAttach(ctx context.Context, container1 string, options container.AttachOptions) (types.HijackedResponse, error) {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerAttach")
	}

	var r0 types.HijackedResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.AttachOptions) (types.HijackedResponse, error)); ok {
		return returnFunc(ctx, container1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.AttachOptions) types.HijackedResponse); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Get(0).(types.HijackedResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.AttachOptions) error); ok {
		r1 = returnFunc(ctx, container1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerAttach_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerAttach'
type MockAPIClient_ContainerAttach_Call struct {
	*mock.Call
}

// ContainerAttach is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.AttachOptions
func (_e *MockAPIClient_Expecter) ContainerAttach(ctx any, container1 any, options any) *MockAPIClient_ContainerAttach_Call {
	return &MockAPIClient_ContainerAttach_Call{Call: _e.mock.On("ContainerAttach", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerAttach_Call) Run(run func(ctx context.Context, container1 string, options container.AttachOptions)) *MockAPIClient_ContainerAttach_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.AttachOptions
		if args[2] != nil {
			arg2 = args[2].(container.AttachOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockAPIClient_ContainerAttach_Call {
	_c.Call.Return(hijackedResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerAttach_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.AttachOptions) (types.HijackedResponse, error)) *MockAPIClient_ContainerAttach_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerCommit provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerCommit(ctx context.Context, container1 string, options container.CommitOptions) (container.CommitResponse, error) {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerCommit")
	}

	var r0 container.CommitResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.CommitOptions) (container.CommitResponse, error)); ok {
		return returnFunc(ctx, container1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.CommitOptions) container.CommitResponse); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Get(0).(container.CommitResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.CommitOptions) error); ok {
		r1 = returnFunc(ctx, container1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerCommit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerCommit'
type MockAPIClient_ContainerCommit_Call struct {
	*mock.Call
}

// ContainerCommit is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.CommitOptions
func (_e *MockAPIClient_Expecter) ContainerCommit(ctx any, container1 any, options any) *MockAPIClient_ContainerCommit_Call {
	return &MockAPIClient_ContainerCommit_Call{Call: _e.mock.On("ContainerCommit", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerCommit_Call) Run(run func(ctx context.Context, container1 string, options container.CommitOptions)) *MockAPIClient_ContainerCommit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.CommitOptions
		if args[2] != nil {
			arg2 = args[2].(container.CommitOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerCommit_Call) Return(commitResponse container.CommitResponse, err error) *MockAPIClient_ContainerCommit_Call {
	_c.Call.Return(commitResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerCommit_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.CommitOptions) (container.CommitResponse, error)) *MockAPIClient_ContainerCommit_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerCreate(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *v1.Platform, containerName string) (container.CreateResponse, error) {
	ret := _mock.Called(ctx, config, hostConfig, networkingConfig, platform, containerName)

	if len(ret) == 0 {
		panic("no return value specified for ContainerCreate")
	}

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

// MockAPIClient_ContainerCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerCreate'
type MockAPIClient_ContainerCreate_Call struct {
	*mock.Call
}

// ContainerCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - config *container.Config
//   - hostConfig *container.HostConfig
//   - networkingConfig *network.NetworkingConfig
//   - platform *v1.Platform
//   - containerName string
func (_e *MockAPIClient_Expecter) ContainerCreate(ctx any, config any, hostConfig any, networkingConfig any, platform any, containerName any) *MockAPIClient_ContainerCreate_Call {
	return &MockAPIClient_ContainerCreate_Call{Call: _e.mock.On("ContainerCreate", ctx, config, hostConfig, networkingConfig, platform, containerName)}
}

func (_c *MockAPIClient_ContainerCreate_Call) Run(run func(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *v1.Platform, containerName string)) *MockAPIClient_ContainerCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *container.Config
		if args[1] != nil {
			arg1 = args[1].(*container.Config)
		}
		var arg2 *container.HostConfig
		if args[2] != nil {
			arg2 = args[2].(*container.HostConfig)
		}
		var arg3 *network.NetworkingConfig
		if args[3] != nil {
			arg3 = args[3].(*network.NetworkingConfig)
		}
		var arg4 *v1.Platform
		if args[4] != nil {
			arg4 = args[4].(*v1.Platform)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerCreate_Call) Return(createResponse container.CreateResponse, err error) *MockAPIClient_ContainerCreate_Call {
	_c.Call.Return(createResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerCreate_Call) RunAndReturn(run func(ctx context.Context, config *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platform *v1.Platform, containerName string) (container.CreateResponse, error)) *MockAPIClient_ContainerCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerDiff provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerDiff(ctx context.Context, container1 string) ([]container.FilesystemChange, error) {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerDiff")
	}

	var r0 []container.FilesystemChange
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]container.FilesystemChange, error)); ok {
		return returnFunc(ctx, container1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []container.FilesystemChange); ok {
		r0 = returnFunc(ctx, container1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]container.FilesystemChange)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, container1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerDiff'
type MockAPIClient_ContainerDiff_Call struct {
	*mock.Call
}

// ContainerDiff is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerDiff(ctx any, container1 any) *MockAPIClient_ContainerDiff_Call {
	return &MockAPIClient_ContainerDiff_Call{Call: _e.mock.On("ContainerDiff", ctx, container1)}
}

func (_c *MockAPIClient_ContainerDiff_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerDiff_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerDiff_Call) Return(filesystemChanges []container.FilesystemChange, err error) *MockAPIClient_ContainerDiff_Call {
	_c.Call.Return(filesystemChanges, err)
	return _c
}

func (_c *MockAPIClient_ContainerDiff_Call) RunAndReturn(run func(ctx context.Context, container1 string) ([]container.FilesystemChange, error)) *MockAPIClient_ContainerDiff_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExecAttach provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExecAttach(ctx context.Context, execID string, options container.ExecAttachOptions) (types.HijackedResponse, error) {
	ret := _mock.Called(ctx, execID, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExecAttach")
	}

	var r0 types.HijackedResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ExecAttachOptions) (types.HijackedResponse, error)); ok {
		return returnFunc(ctx, execID, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ExecAttachOptions) types.HijackedResponse); ok {
		r0 = returnFunc(ctx, execID, options)
	} else {
		r0 = ret.Get(0).(types.HijackedResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.ExecAttachOptions) error); ok {
		r1 = returnFunc(ctx, execID, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerExecAttach_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExecAttach'
type MockAPIClient_ContainerExecAttach_Call struct {
	*mock.Call
}

// ContainerExecAttach is a helper method to define mock.On call
//   - ctx context.Context
//   - execID string
//   - options container.ExecAttachOptions
func (_e *MockAPIClient_Expecter) ContainerExecAttach(ctx any, execID any, options any) *MockAPIClient_ContainerExecAttach_Call {
	return &MockAPIClient_ContainerExecAttach_Call{Call: _e.mock.On("ContainerExecAttach", ctx, execID, options)}
}

func (_c *MockAPIClient_ContainerExecAttach_Call) Run(run func(ctx context.Context, execID string, options container.ExecAttachOptions)) *MockAPIClient_ContainerExecAttach_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.ExecAttachOptions
		if args[2] != nil {
			arg2 = args[2].(container.ExecAttachOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExecAttach_Call) Return(hijackedResponse types.HijackedResponse, err error) *MockAPIClient_ContainerExecAttach_Call {
	_c.Call.Return(hijackedResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerExecAttach_Call) RunAndReturn(run func(ctx context.Context, execID string, options container.ExecAttachOptions) (types.HijackedResponse, error)) *MockAPIClient_ContainerExecAttach_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExecCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExecCreate(ctx context.Context, container1 string, options container.ExecOptions) (container.ExecCreateResponse, error) {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExecCreate")
	}

	var r0 container.ExecCreateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ExecOptions) (container.ExecCreateResponse, error)); ok {
		return returnFunc(ctx, container1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ExecOptions) container.ExecCreateResponse); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Get(0).(container.ExecCreateResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.ExecOptions) error); ok {
		r1 = returnFunc(ctx, container1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerExecCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExecCreate'
type MockAPIClient_ContainerExecCreate_Call struct {
	*mock.Call
}

// ContainerExecCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.ExecOptions
func (_e *MockAPIClient_Expecter) ContainerExecCreate(ctx any, container1 any, options any) *MockAPIClient_ContainerExecCreate_Call {
	return &MockAPIClient_ContainerExecCreate_Call{Call: _e.mock.On("ContainerExecCreate", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerExecCreate_Call) Run(run func(ctx context.Context, container1 string, options container.ExecOptions)) *MockAPIClient_ContainerExecCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.ExecOptions
		if args[2] != nil {
			arg2 = args[2].(container.ExecOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExecCreate_Call) Return(execCreateResponse container.ExecCreateResponse, err error) *MockAPIClient_ContainerExecCreate_Call {
	_c.Call.Return(execCreateResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerExecCreate_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.ExecOptions) (container.ExecCreateResponse, error)) *MockAPIClient_ContainerExecCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExecInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExecInspect(ctx context.Context, execID string) (container.ExecInspect, error) {
	ret := _mock.Called(ctx, execID)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExecInspect")
	}

	var r0 container.ExecInspect
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (container.ExecInspect, error)); ok {
		return returnFunc(ctx, execID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) container.ExecInspect); ok {
		r0 = returnFunc(ctx, execID)
	} else {
		r0 = ret.Get(0).(container.ExecInspect)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, execID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerExecInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExecInspect'
type MockAPIClient_ContainerExecInspect_Call struct {
	*mock.Call
}

// ContainerExecInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - execID string
func (_e *MockAPIClient_Expecter) ContainerExecInspect(ctx any, execID any) *MockAPIClient_ContainerExecInspect_Call {
	return &MockAPIClient_ContainerExecInspect_Call{Call: _e.mock.On("ContainerExecInspect", ctx, execID)}
}

func (_c *MockAPIClient_ContainerExecInspect_Call) Run(run func(ctx context.Context, execID string)) *MockAPIClient_ContainerExecInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExecInspect_Call) Return(execInspect container.ExecInspect, err error) *MockAPIClient_ContainerExecInspect_Call {
	_c.Call.Return(execInspect, err)
	return _c
}

func (_c *MockAPIClient_ContainerExecInspect_Call) RunAndReturn(run func(ctx context.Context, execID string) (container.ExecInspect, error)) *MockAPIClient_ContainerExecInspect_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExecResize provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExecResize(ctx context.Context, execID string, options container.ResizeOptions) error {
	ret := _mock.Called(ctx, execID, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExecResize")
	}

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

// MockAPIClient_ContainerExecResize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExecResize'
type MockAPIClient_ContainerExecResize_Call struct {
	*mock.Call
}

// ContainerExecResize is a helper method to define mock.On call
//   - ctx context.Context
//   - execID string
//   - options container.ResizeOptions
func (_e *MockAPIClient_Expecter) ContainerExecResize(ctx any, execID any, options any) *MockAPIClient_ContainerExecResize_Call {
	return &MockAPIClient_ContainerExecResize_Call{Call: _e.mock.On("ContainerExecResize", ctx, execID, options)}
}

func (_c *MockAPIClient_ContainerExecResize_Call) Run(run func(ctx context.Context, execID string, options container.ResizeOptions)) *MockAPIClient_ContainerExecResize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.ResizeOptions
		if args[2] != nil {
			arg2 = args[2].(container.ResizeOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExecResize_Call) Return(err error) *MockAPIClient_ContainerExecResize_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerExecResize_Call) RunAndReturn(run func(ctx context.Context, execID string, options container.ResizeOptions) error) *MockAPIClient_ContainerExecResize_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExecStart provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExecStart(ctx context.Context, execID string, options container.ExecStartOptions) error {
	ret := _mock.Called(ctx, execID, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExecStart")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ExecStartOptions) error); ok {
		r0 = returnFunc(ctx, execID, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_ContainerExecStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExecStart'
type MockAPIClient_ContainerExecStart_Call struct {
	*mock.Call
}

// ContainerExecStart is a helper method to define mock.On call
//   - ctx context.Context
//   - execID string
//   - options container.ExecStartOptions
func (_e *MockAPIClient_Expecter) ContainerExecStart(ctx any, execID any, options any) *MockAPIClient_ContainerExecStart_Call {
	return &MockAPIClient_ContainerExecStart_Call{Call: _e.mock.On("ContainerExecStart", ctx, execID, options)}
}

func (_c *MockAPIClient_ContainerExecStart_Call) Run(run func(ctx context.Context, execID string, options container.ExecStartOptions)) *MockAPIClient_ContainerExecStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.ExecStartOptions
		if args[2] != nil {
			arg2 = args[2].(container.ExecStartOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExecStart_Call) Return(err error) *MockAPIClient_ContainerExecStart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerExecStart_Call) RunAndReturn(run func(ctx context.Context, execID string, options container.ExecStartOptions) error) *MockAPIClient_ContainerExecStart_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerExport provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerExport(ctx context.Context, container1 string) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerExport")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, container1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) io.ReadCloser); ok {
		r0 = returnFunc(ctx, container1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, container1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerExport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerExport'
type MockAPIClient_ContainerExport_Call struct {
	*mock.Call
}

// ContainerExport is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerExport(ctx any, container1 any) *MockAPIClient_ContainerExport_Call {
	return &MockAPIClient_ContainerExport_Call{Call: _e.mock.On("ContainerExport", ctx, container1)}
}

func (_c *MockAPIClient_ContainerExport_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerExport_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ContainerExport_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ContainerExport_Call) RunAndReturn(run func(ctx context.Context, container1 string) (io.ReadCloser, error)) *MockAPIClient_ContainerExport_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerInspect(ctx context.Context, container1 string) (container.InspectResponse, error) {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerInspect")
	}

	var r0 container.InspectResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (container.InspectResponse, error)); ok {
		return returnFunc(ctx, container1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) container.InspectResponse); ok {
		r0 = returnFunc(ctx, container1)
	} else {
		r0 = ret.Get(0).(container.InspectResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, container1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerInspect'
type MockAPIClient_ContainerInspect_Call struct {
	*mock.Call
}

// ContainerInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerInspect(ctx any, container1 any) *MockAPIClient_ContainerInspect_Call {
	return &MockAPIClient_ContainerInspect_Call{Call: _e.mock.On("ContainerInspect", ctx, container1)}
}

func (_c *MockAPIClient_ContainerInspect_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerInspect_Call) Return(inspectResponse container.InspectResponse, err error) *MockAPIClient_ContainerInspect_Call {
	_c.Call.Return(inspectResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerInspect_Call) RunAndReturn(run func(ctx context.Context, container1 string) (container.InspectResponse, error)) *MockAPIClient_ContainerInspect_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerInspectWithRaw(ctx context.Context, container1 string, getSize bool) (container.InspectResponse, []byte, error) {
	ret := _mock.Called(ctx, container1, getSize)

	if len(ret) == 0 {
		panic("no return value specified for ContainerInspectWithRaw")
	}

	var r0 container.InspectResponse
	var r1 []byte
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (container.InspectResponse, []byte, error)); ok {
		return returnFunc(ctx, container1, getSize)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) container.InspectResponse); ok {
		r0 = returnFunc(ctx, container1, getSize)
	} else {
		r0 = ret.Get(0).(container.InspectResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) []byte); ok {
		r1 = returnFunc(ctx, container1, getSize)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, bool) error); ok {
		r2 = returnFunc(ctx, container1, getSize)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockAPIClient_ContainerInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerInspectWithRaw'
type MockAPIClient_ContainerInspectWithRaw_Call struct {
	*mock.Call
}

// ContainerInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - getSize bool
func (_e *MockAPIClient_Expecter) ContainerInspectWithRaw(ctx any, container1 any, getSize any) *MockAPIClient_ContainerInspectWithRaw_Call {
	return &MockAPIClient_ContainerInspectWithRaw_Call{Call: _e.mock.On("ContainerInspectWithRaw", ctx, container1, getSize)}
}

func (_c *MockAPIClient_ContainerInspectWithRaw_Call) Run(run func(ctx context.Context, container1 string, getSize bool)) *MockAPIClient_ContainerInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerInspectWithRaw_Call) Return(inspectResponse container.InspectResponse, bytes []byte, err error) *MockAPIClient_ContainerInspectWithRaw_Call {
	_c.Call.Return(inspectResponse, bytes, err)
	return _c
}

func (_c *MockAPIClient_ContainerInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, container1 string, getSize bool) (container.InspectResponse, []byte, error)) *MockAPIClient_ContainerInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerKill provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerKill(ctx context.Context, container1 string, signal string) error {
	ret := _mock.Called(ctx, container1, signal)

	if len(ret) == 0 {
		panic("no return value specified for ContainerKill")
	}

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

// MockAPIClient_ContainerKill_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerKill'
type MockAPIClient_ContainerKill_Call struct {
	*mock.Call
}

// ContainerKill is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - signal string
func (_e *MockAPIClient_Expecter) ContainerKill(ctx any, container1 any, signal any) *MockAPIClient_ContainerKill_Call {
	return &MockAPIClient_ContainerKill_Call{Call: _e.mock.On("ContainerKill", ctx, container1, signal)}
}

func (_c *MockAPIClient_ContainerKill_Call) Run(run func(ctx context.Context, container1 string, signal string)) *MockAPIClient_ContainerKill_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerKill_Call) Return(err error) *MockAPIClient_ContainerKill_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerKill_Call) RunAndReturn(run func(ctx context.Context, container1 string, signal string) error) *MockAPIClient_ContainerKill_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerList(ctx context.Context, options container.ListOptions) ([]container.Summary, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerList")
	}

	var r0 []container.Summary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, container.ListOptions) ([]container.Summary, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, container.ListOptions) []container.Summary); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]container.Summary)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, container.ListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerList'
type MockAPIClient_ContainerList_Call struct {
	*mock.Call
}

// ContainerList is a helper method to define mock.On call
//   - ctx context.Context
//   - options container.ListOptions
func (_e *MockAPIClient_Expecter) ContainerList(ctx any, options any) *MockAPIClient_ContainerList_Call {
	return &MockAPIClient_ContainerList_Call{Call: _e.mock.On("ContainerList", ctx, options)}
}

func (_c *MockAPIClient_ContainerList_Call) Run(run func(ctx context.Context, options container.ListOptions)) *MockAPIClient_ContainerList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 container.ListOptions
		if args[1] != nil {
			arg1 = args[1].(container.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerList_Call) Return(summarys []container.Summary, err error) *MockAPIClient_ContainerList_Call {
	_c.Call.Return(summarys, err)
	return _c
}

func (_c *MockAPIClient_ContainerList_Call) RunAndReturn(run func(ctx context.Context, options container.ListOptions) ([]container.Summary, error)) *MockAPIClient_ContainerList_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerLogs provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerLogs(ctx context.Context, container1 string, options container.LogsOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerLogs")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, container1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.LogsOptions) error); ok {
		r1 = returnFunc(ctx, container1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerLogs'
type MockAPIClient_ContainerLogs_Call struct {
	*mock.Call
}

// ContainerLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.LogsOptions
func (_e *MockAPIClient_Expecter) ContainerLogs(ctx any, container1 any, options any) *MockAPIClient_ContainerLogs_Call {
	return &MockAPIClient_ContainerLogs_Call{Call: _e.mock.On("ContainerLogs", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerLogs_Call) Run(run func(ctx context.Context, container1 string, options container.LogsOptions)) *MockAPIClient_ContainerLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.LogsOptions
		if args[2] != nil {
			arg2 = args[2].(container.LogsOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ContainerLogs_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ContainerLogs_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.LogsOptions) (io.ReadCloser, error)) *MockAPIClient_ContainerLogs_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerPause provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerPause(ctx context.Context, container1 string) error {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerPause")
	}

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

// MockAPIClient_ContainerPause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerPause'
type MockAPIClient_ContainerPause_Call struct {
	*mock.Call
}

// ContainerPause is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerPause(ctx any, container1 any) *MockAPIClient_ContainerPause_Call {
	return &MockAPIClient_ContainerPause_Call{Call: _e.mock.On("ContainerPause", ctx, container1)}
}

func (_c *MockAPIClient_ContainerPause_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerPause_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerPause_Call) Return(err error) *MockAPIClient_ContainerPause_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerPause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockAPIClient_ContainerPause_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerRemove(ctx context.Context, container1 string, options container.RemoveOptions) error {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerRemove")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.RemoveOptions) error); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_ContainerRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerRemove'
type MockAPIClient_ContainerRemove_Call struct {
	*mock.Call
}

// ContainerRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.RemoveOptions
func (_e *MockAPIClient_Expecter) ContainerRemove(ctx any, container1 any, options any) *MockAPIClient_ContainerRemove_Call {
	return &MockAPIClient_ContainerRemove_Call{Call: _e.mock.On("ContainerRemove", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerRemove_Call) Run(run func(ctx context.Context, container1 string, options container.RemoveOptions)) *MockAPIClient_ContainerRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.RemoveOptions
		if args[2] != nil {
			arg2 = args[2].(container.RemoveOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerRemove_Call) Return(err error) *MockAPIClient_ContainerRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerRemove_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.RemoveOptions) error) *MockAPIClient_ContainerRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerRename provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerRename(ctx context.Context, container1 string, newContainerName string) error {
	ret := _mock.Called(ctx, container1, newContainerName)

	if len(ret) == 0 {
		panic("no return value specified for ContainerRename")
	}

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

// MockAPIClient_ContainerRename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerRename'
type MockAPIClient_ContainerRename_Call struct {
	*mock.Call
}

// ContainerRename is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - newContainerName string
func (_e *MockAPIClient_Expecter) ContainerRename(ctx any, container1 any, newContainerName any) *MockAPIClient_ContainerRename_Call {
	return &MockAPIClient_ContainerRename_Call{Call: _e.mock.On("ContainerRename", ctx, container1, newContainerName)}
}

func (_c *MockAPIClient_ContainerRename_Call) Run(run func(ctx context.Context, container1 string, newContainerName string)) *MockAPIClient_ContainerRename_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerRename_Call) Return(err error) *MockAPIClient_ContainerRename_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerRename_Call) RunAndReturn(run func(ctx context.Context, container1 string, newContainerName string) error) *MockAPIClient_ContainerRename_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerResize provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerResize(ctx context.Context, container1 string, options container.ResizeOptions) error {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerResize")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.ResizeOptions) error); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_ContainerResize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerResize'
type MockAPIClient_ContainerResize_Call struct {
	*mock.Call
}

// ContainerResize is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.ResizeOptions
func (_e *MockAPIClient_Expecter) ContainerResize(ctx any, container1 any, options any) *MockAPIClient_ContainerResize_Call {
	return &MockAPIClient_ContainerResize_Call{Call: _e.mock.On("ContainerResize", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerResize_Call) Run(run func(ctx context.Context, container1 string, options container.ResizeOptions)) *MockAPIClient_ContainerResize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.ResizeOptions
		if args[2] != nil {
			arg2 = args[2].(container.ResizeOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerResize_Call) Return(err error) *MockAPIClient_ContainerResize_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerResize_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.ResizeOptions) error) *MockAPIClient_ContainerResize_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerRestart provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerRestart(ctx context.Context, container1 string, options container.StopOptions) error {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerRestart")
	}

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

// MockAPIClient_ContainerRestart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerRestart'
type MockAPIClient_ContainerRestart_Call struct {
	*mock.Call
}

// ContainerRestart is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.StopOptions
func (_e *MockAPIClient_Expecter) ContainerRestart(ctx any, container1 any, options any) *MockAPIClient_ContainerRestart_Call {
	return &MockAPIClient_ContainerRestart_Call{Call: _e.mock.On("ContainerRestart", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerRestart_Call) Run(run func(ctx context.Context, container1 string, options container.StopOptions)) *MockAPIClient_ContainerRestart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.StopOptions
		if args[2] != nil {
			arg2 = args[2].(container.StopOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerRestart_Call) Return(err error) *MockAPIClient_ContainerRestart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerRestart_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.StopOptions) error) *MockAPIClient_ContainerRestart_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerStart provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerStart(ctx context.Context, container1 string, options container.StartOptions) error {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerStart")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.StartOptions) error); ok {
		r0 = returnFunc(ctx, container1, options)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockAPIClient_ContainerStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerStart'
type MockAPIClient_ContainerStart_Call struct {
	*mock.Call
}

// ContainerStart is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.StartOptions
func (_e *MockAPIClient_Expecter) ContainerStart(ctx any, container1 any, options any) *MockAPIClient_ContainerStart_Call {
	return &MockAPIClient_ContainerStart_Call{Call: _e.mock.On("ContainerStart", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerStart_Call) Run(run func(ctx context.Context, container1 string, options container.StartOptions)) *MockAPIClient_ContainerStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.StartOptions
		if args[2] != nil {
			arg2 = args[2].(container.StartOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerStart_Call) Return(err error) *MockAPIClient_ContainerStart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerStart_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.StartOptions) error) *MockAPIClient_ContainerStart_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerStatPath provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerStatPath(ctx context.Context, container1 string, path string) (container.PathStat, error) {
	ret := _mock.Called(ctx, container1, path)

	if len(ret) == 0 {
		panic("no return value specified for ContainerStatPath")
	}

	var r0 container.PathStat
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (container.PathStat, error)); ok {
		return returnFunc(ctx, container1, path)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) container.PathStat); ok {
		r0 = returnFunc(ctx, container1, path)
	} else {
		r0 = ret.Get(0).(container.PathStat)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, container1, path)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerStatPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerStatPath'
type MockAPIClient_ContainerStatPath_Call struct {
	*mock.Call
}

// ContainerStatPath is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - path string
func (_e *MockAPIClient_Expecter) ContainerStatPath(ctx any, container1 any, path any) *MockAPIClient_ContainerStatPath_Call {
	return &MockAPIClient_ContainerStatPath_Call{Call: _e.mock.On("ContainerStatPath", ctx, container1, path)}
}

func (_c *MockAPIClient_ContainerStatPath_Call) Run(run func(ctx context.Context, container1 string, path string)) *MockAPIClient_ContainerStatPath_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerStatPath_Call) Return(pathStat container.PathStat, err error) *MockAPIClient_ContainerStatPath_Call {
	_c.Call.Return(pathStat, err)
	return _c
}

func (_c *MockAPIClient_ContainerStatPath_Call) RunAndReturn(run func(ctx context.Context, container1 string, path string) (container.PathStat, error)) *MockAPIClient_ContainerStatPath_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerStats provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerStats(ctx context.Context, container1 string, stream bool) (container.StatsResponseReader, error) {
	ret := _mock.Called(ctx, container1, stream)

	if len(ret) == 0 {
		panic("no return value specified for ContainerStats")
	}

	var r0 container.StatsResponseReader
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) (container.StatsResponseReader, error)); ok {
		return returnFunc(ctx, container1, stream)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, bool) container.StatsResponseReader); ok {
		r0 = returnFunc(ctx, container1, stream)
	} else {
		r0 = ret.Get(0).(container.StatsResponseReader)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, bool) error); ok {
		r1 = returnFunc(ctx, container1, stream)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerStats'
type MockAPIClient_ContainerStats_Call struct {
	*mock.Call
}

// ContainerStats is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - stream bool
func (_e *MockAPIClient_Expecter) ContainerStats(ctx any, container1 any, stream any) *MockAPIClient_ContainerStats_Call {
	return &MockAPIClient_ContainerStats_Call{Call: _e.mock.On("ContainerStats", ctx, container1, stream)}
}

func (_c *MockAPIClient_ContainerStats_Call) Run(run func(ctx context.Context, container1 string, stream bool)) *MockAPIClient_ContainerStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerStats_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockAPIClient_ContainerStats_Call {
	_c.Call.Return(statsResponseReader, err)
	return _c
}

func (_c *MockAPIClient_ContainerStats_Call) RunAndReturn(run func(ctx context.Context, container1 string, stream bool) (container.StatsResponseReader, error)) *MockAPIClient_ContainerStats_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerStatsOneShot provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerStatsOneShot(ctx context.Context, container1 string) (container.StatsResponseReader, error) {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerStatsOneShot")
	}

	var r0 container.StatsResponseReader
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (container.StatsResponseReader, error)); ok {
		return returnFunc(ctx, container1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) container.StatsResponseReader); ok {
		r0 = returnFunc(ctx, container1)
	} else {
		r0 = ret.Get(0).(container.StatsResponseReader)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, container1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerStatsOneShot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerStatsOneShot'
type MockAPIClient_ContainerStatsOneShot_Call struct {
	*mock.Call
}

// ContainerStatsOneShot is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerStatsOneShot(ctx any, container1 any) *MockAPIClient_ContainerStatsOneShot_Call {
	return &MockAPIClient_ContainerStatsOneShot_Call{Call: _e.mock.On("ContainerStatsOneShot", ctx, container1)}
}

func (_c *MockAPIClient_ContainerStatsOneShot_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerStatsOneShot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerStatsOneShot_Call) Return(statsResponseReader container.StatsResponseReader, err error) *MockAPIClient_ContainerStatsOneShot_Call {
	_c.Call.Return(statsResponseReader, err)
	return _c
}

func (_c *MockAPIClient_ContainerStatsOneShot_Call) RunAndReturn(run func(ctx context.Context, container1 string) (container.StatsResponseReader, error)) *MockAPIClient_ContainerStatsOneShot_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerStop provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerStop(ctx context.Context, container1 string, options container.StopOptions) error {
	ret := _mock.Called(ctx, container1, options)

	if len(ret) == 0 {
		panic("no return value specified for ContainerStop")
	}

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

// MockAPIClient_ContainerStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerStop'
type MockAPIClient_ContainerStop_Call struct {
	*mock.Call
}

// ContainerStop is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - options container.StopOptions
func (_e *MockAPIClient_Expecter) ContainerStop(ctx any, container1 any, options any) *MockAPIClient_ContainerStop_Call {
	return &MockAPIClient_ContainerStop_Call{Call: _e.mock.On("ContainerStop", ctx, container1, options)}
}

func (_c *MockAPIClient_ContainerStop_Call) Run(run func(ctx context.Context, container1 string, options container.StopOptions)) *MockAPIClient_ContainerStop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.StopOptions
		if args[2] != nil {
			arg2 = args[2].(container.StopOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerStop_Call) Return(err error) *MockAPIClient_ContainerStop_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerStop_Call) RunAndReturn(run func(ctx context.Context, container1 string, options container.StopOptions) error) *MockAPIClient_ContainerStop_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerTop provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerTop(ctx context.Context, container1 string, arguments []string) (container.TopResponse, error) {
	ret := _mock.Called(ctx, container1, arguments)

	if len(ret) == 0 {
		panic("no return value specified for ContainerTop")
	}

	var r0 container.TopResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) (container.TopResponse, error)); ok {
		return returnFunc(ctx, container1, arguments)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) container.TopResponse); ok {
		r0 = returnFunc(ctx, container1, arguments)
	} else {
		r0 = ret.Get(0).(container.TopResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = returnFunc(ctx, container1, arguments)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerTop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerTop'
type MockAPIClient_ContainerTop_Call struct {
	*mock.Call
}

// ContainerTop is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - arguments []string
func (_e *MockAPIClient_Expecter) ContainerTop(ctx any, container1 any, arguments any) *MockAPIClient_ContainerTop_Call {
	return &MockAPIClient_ContainerTop_Call{Call: _e.mock.On("ContainerTop", ctx, container1, arguments)}
}

func (_c *MockAPIClient_ContainerTop_Call) Run(run func(ctx context.Context, container1 string, arguments []string)) *MockAPIClient_ContainerTop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerTop_Call) Return(topResponse container.TopResponse, err error) *MockAPIClient_ContainerTop_Call {
	_c.Call.Return(topResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerTop_Call) RunAndReturn(run func(ctx context.Context, container1 string, arguments []string) (container.TopResponse, error)) *MockAPIClient_ContainerTop_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerUnpause provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerUnpause(ctx context.Context, container1 string) error {
	ret := _mock.Called(ctx, container1)

	if len(ret) == 0 {
		panic("no return value specified for ContainerUnpause")
	}

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

// MockAPIClient_ContainerUnpause_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerUnpause'
type MockAPIClient_ContainerUnpause_Call struct {
	*mock.Call
}

// ContainerUnpause is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
func (_e *MockAPIClient_Expecter) ContainerUnpause(ctx any, container1 any) *MockAPIClient_ContainerUnpause_Call {
	return &MockAPIClient_ContainerUnpause_Call{Call: _e.mock.On("ContainerUnpause", ctx, container1)}
}

func (_c *MockAPIClient_ContainerUnpause_Call) Run(run func(ctx context.Context, container1 string)) *MockAPIClient_ContainerUnpause_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerUnpause_Call) Return(err error) *MockAPIClient_ContainerUnpause_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ContainerUnpause_Call) RunAndReturn(run func(ctx context.Context, container1 string) error) *MockAPIClient_ContainerUnpause_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerUpdate(ctx context.Context, container1 string, updateConfig container.UpdateConfig) (container.UpdateResponse, error) {
	ret := _mock.Called(ctx, container1, updateConfig)

	if len(ret) == 0 {
		panic("no return value specified for ContainerUpdate")
	}

	var r0 container.UpdateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.UpdateConfig) (container.UpdateResponse, error)); ok {
		return returnFunc(ctx, container1, updateConfig)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.UpdateConfig) container.UpdateResponse); ok {
		r0 = returnFunc(ctx, container1, updateConfig)
	} else {
		r0 = ret.Get(0).(container.UpdateResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.UpdateConfig) error); ok {
		r1 = returnFunc(ctx, container1, updateConfig)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainerUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerUpdate'
type MockAPIClient_ContainerUpdate_Call struct {
	*mock.Call
}

// ContainerUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - updateConfig container.UpdateConfig
func (_e *MockAPIClient_Expecter) ContainerUpdate(ctx any, container1 any, updateConfig any) *MockAPIClient_ContainerUpdate_Call {
	return &MockAPIClient_ContainerUpdate_Call{Call: _e.mock.On("ContainerUpdate", ctx, container1, updateConfig)}
}

func (_c *MockAPIClient_ContainerUpdate_Call) Run(run func(ctx context.Context, container1 string, updateConfig container.UpdateConfig)) *MockAPIClient_ContainerUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.UpdateConfig
		if args[2] != nil {
			arg2 = args[2].(container.UpdateConfig)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerUpdate_Call) Return(updateResponse container.UpdateResponse, err error) *MockAPIClient_ContainerUpdate_Call {
	_c.Call.Return(updateResponse, err)
	return _c
}

func (_c *MockAPIClient_ContainerUpdate_Call) RunAndReturn(run func(ctx context.Context, container1 string, updateConfig container.UpdateConfig) (container.UpdateResponse, error)) *MockAPIClient_ContainerUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ContainerWait provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainerWait(ctx context.Context, container1 string, condition container.WaitCondition) (<-chan container.WaitResponse, <-chan error) {
	ret := _mock.Called(ctx, container1, condition)

	if len(ret) == 0 {
		panic("no return value specified for ContainerWait")
	}

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

// MockAPIClient_ContainerWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainerWait'
type MockAPIClient_ContainerWait_Call struct {
	*mock.Call
}

// ContainerWait is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - condition container.WaitCondition
func (_e *MockAPIClient_Expecter) ContainerWait(ctx any, container1 any, condition any) *MockAPIClient_ContainerWait_Call {
	return &MockAPIClient_ContainerWait_Call{Call: _e.mock.On("ContainerWait", ctx, container1, condition)}
}

func (_c *MockAPIClient_ContainerWait_Call) Run(run func(ctx context.Context, container1 string, condition container.WaitCondition)) *MockAPIClient_ContainerWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.WaitCondition
		if args[2] != nil {
			arg2 = args[2].(container.WaitCondition)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainerWait_Call) Return(waitResponseCh <-chan container.WaitResponse, errCh <-chan error) *MockAPIClient_ContainerWait_Call {
	_c.Call.Return(waitResponseCh, errCh)
	return _c
}

func (_c *MockAPIClient_ContainerWait_Call) RunAndReturn(run func(ctx context.Context, container1 string, condition container.WaitCondition) (<-chan container.WaitResponse, <-chan error)) *MockAPIClient_ContainerWait_Call {
	_c.Call.Return(run)
	return _c
}

// ContainersPrune provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (container.PruneReport, error) {
	ret := _mock.Called(ctx, pruneFilters)

	if len(ret) == 0 {
		panic("no return value specified for ContainersPrune")
	}

	var r0 container.PruneReport
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) (container.PruneReport, error)); ok {
		return returnFunc(ctx, pruneFilters)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) container.PruneReport); ok {
		r0 = returnFunc(ctx, pruneFilters)
	} else {
		r0 = ret.Get(0).(container.PruneReport)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = returnFunc(ctx, pruneFilters)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ContainersPrune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContainersPrune'
type MockAPIClient_ContainersPrune_Call struct {
	*mock.Call
}

// ContainersPrune is a helper method to define mock.On call
//   - ctx context.Context
//   - pruneFilters filters.Args
func (_e *MockAPIClient_Expecter) ContainersPrune(ctx any, pruneFilters any) *MockAPIClient_ContainersPrune_Call {
	return &MockAPIClient_ContainersPrune_Call{Call: _e.mock.On("ContainersPrune", ctx, pruneFilters)}
}

func (_c *MockAPIClient_ContainersPrune_Call) Run(run func(ctx context.Context, pruneFilters filters.Args)) *MockAPIClient_ContainersPrune_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 filters.Args
		if args[1] != nil {
			arg1 = args[1].(filters.Args)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ContainersPrune_Call) Return(pruneReport container.PruneReport, err error) *MockAPIClient_ContainersPrune_Call {
	_c.Call.Return(pruneReport, err)
	return _c
}

func (_c *MockAPIClient_ContainersPrune_Call) RunAndReturn(run func(ctx context.Context, pruneFilters filters.Args) (container.PruneReport, error)) *MockAPIClient_ContainersPrune_Call {
	_c.Call.Return(run)
	return _c
}

// CopyFromContainer provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) CopyFromContainer(ctx context.Context, container1 string, srcPath string) (io.ReadCloser, container.PathStat, error) {
	ret := _mock.Called(ctx, container1, srcPath)

	if len(ret) == 0 {
		panic("no return value specified for CopyFromContainer")
	}

	var r0 io.ReadCloser
	var r1 container.PathStat
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (io.ReadCloser, container.PathStat, error)); ok {
		return returnFunc(ctx, container1, srcPath)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) io.ReadCloser); ok {
		r0 = returnFunc(ctx, container1, srcPath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) container.PathStat); ok {
		r1 = returnFunc(ctx, container1, srcPath)
	} else {
		r1 = ret.Get(1).(container.PathStat)
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, string) error); ok {
		r2 = returnFunc(ctx, container1, srcPath)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockAPIClient_CopyFromContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyFromContainer'
type MockAPIClient_CopyFromContainer_Call struct {
	*mock.Call
}

// CopyFromContainer is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - srcPath string
func (_e *MockAPIClient_Expecter) CopyFromContainer(ctx any, container1 any, srcPath any) *MockAPIClient_CopyFromContainer_Call {
	return &MockAPIClient_CopyFromContainer_Call{Call: _e.mock.On("CopyFromContainer", ctx, container1, srcPath)}
}

func (_c *MockAPIClient_CopyFromContainer_Call) Run(run func(ctx context.Context, container1 string, srcPath string)) *MockAPIClient_CopyFromContainer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_CopyFromContainer_Call) Return(readCloser io.ReadCloser, pathStat container.PathStat, err error) *MockAPIClient_CopyFromContainer_Call {
	_c.Call.Return(readCloser, pathStat, err)
	return _c
}

func (_c *MockAPIClient_CopyFromContainer_Call) RunAndReturn(run func(ctx context.Context, container1 string, srcPath string) (io.ReadCloser, container.PathStat, error)) *MockAPIClient_CopyFromContainer_Call {
	_c.Call.Return(run)
	return _c
}

// CopyToContainer provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) CopyToContainer(ctx context.Context, container1 string, path string, content io.Reader, options container.CopyToContainerOptions) error {
	ret := _mock.Called(ctx, container1, path, content, options)

	if len(ret) == 0 {
		panic("no return value specified for CopyToContainer")
	}

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

// MockAPIClient_CopyToContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyToContainer'
type MockAPIClient_CopyToContainer_Call struct {
	*mock.Call
}

// CopyToContainer is a helper method to define mock.On call
//   - ctx context.Context
//   - container1 string
//   - path string
//   - content io.Reader
//   - options container.CopyToContainerOptions
func (_e *MockAPIClient_Expecter) CopyToContainer(ctx any, container1 any, path any, content any, options any) *MockAPIClient_CopyToContainer_Call {
	return &MockAPIClient_CopyToContainer_Call{Call: _e.mock.On("CopyToContainer", ctx, container1, path, content, options)}
}

func (_c *MockAPIClient_CopyToContainer_Call) Run(run func(ctx context.Context, container1 string, path string, content io.Reader, options container.CopyToContainerOptions)) *MockAPIClient_CopyToContainer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 io.Reader
		if args[3] != nil {
			arg3 = args[3].(io.Reader)
		}
		var arg4 container.CopyToContainerOptions
		if args[4] != nil {
			arg4 = args[4].(container.CopyToContainerOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockAPIClient_CopyToContainer_Call) Return(err error) *MockAPIClient_CopyToContainer_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_CopyToContainer_Call) RunAndReturn(run func(ctx context.Context, container1 string, path string, content io.Reader, options container.CopyToContainerOptions) error) *MockAPIClient_CopyToContainer_Call {
	_c.Call.Return(run)
	return _c
}

// DaemonHost provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) DaemonHost() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for DaemonHost")
	}

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

// MockAPIClient_DaemonHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DaemonHost'
type MockAPIClient_DaemonHost_Call struct {
	*mock.Call
}

// DaemonHost is a helper method to define mock.On call
func (_e *MockAPIClient_Expecter) DaemonHost() *MockAPIClient_DaemonHost_Call {
	return &MockAPIClient_DaemonHost_Call{Call: _e.mock.On("DaemonHost")}
}

func (_c *MockAPIClient_DaemonHost_Call) Run(run func()) *MockAPIClient_DaemonHost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockAPIClient_DaemonHost_Call) Return(s string) *MockAPIClient_DaemonHost_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockAPIClient_DaemonHost_Call) RunAndReturn(run func() string) *MockAPIClient_DaemonHost_Call {
	_c.Call.Return(run)
	return _c
}

// DialHijack provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) DialHijack(ctx context.Context, url string, proto string, meta map[string][]string) (net.Conn, error) {
	ret := _mock.Called(ctx, url, proto, meta)

	if len(ret) == 0 {
		panic("no return value specified for DialHijack")
	}

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

// MockAPIClient_DialHijack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialHijack'
type MockAPIClient_DialHijack_Call struct {
	*mock.Call
}

// DialHijack is a helper method to define mock.On call
//   - ctx context.Context
//   - url string
//   - proto string
//   - meta map[string][]string
func (_e *MockAPIClient_Expecter) DialHijack(ctx any, url any, proto any, meta any) *MockAPIClient_DialHijack_Call {
	return &MockAPIClient_DialHijack_Call{Call: _e.mock.On("DialHijack", ctx, url, proto, meta)}
}

func (_c *MockAPIClient_DialHijack_Call) Run(run func(ctx context.Context, url string, proto string, meta map[string][]string)) *MockAPIClient_DialHijack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 map[string][]string
		if args[3] != nil {
			arg3 = args[3].(map[string][]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_DialHijack_Call) Return(conn net.Conn, err error) *MockAPIClient_DialHijack_Call {
	_c.Call.Return(conn, err)
	return _c
}

func (_c *MockAPIClient_DialHijack_Call) RunAndReturn(run func(ctx context.Context, url string, proto string, meta map[string][]string) (net.Conn, error)) *MockAPIClient_DialHijack_Call {
	_c.Call.Return(run)
	return _c
}

// Dialer provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) Dialer() func(context.Context) (net.Conn, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Dialer")
	}

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

// MockAPIClient_Dialer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dialer'
type MockAPIClient_Dialer_Call struct {
	*mock.Call
}

// Dialer is a helper method to define mock.On call
func (_e *MockAPIClient_Expecter) Dialer() *MockAPIClient_Dialer_Call {
	return &MockAPIClient_Dialer_Call{Call: _e.mock.On("Dialer")}
}

func (_c *MockAPIClient_Dialer_Call) Run(run func()) *MockAPIClient_Dialer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockAPIClient_Dialer_Call) Return(fn func(context.Context) (net.Conn, error)) *MockAPIClient_Dialer_Call {
	_c.Call.Return(fn)
	return _c
}

func (_c *MockAPIClient_Dialer_Call) RunAndReturn(run func() func(context.Context) (net.Conn, error)) *MockAPIClient_Dialer_Call {
	_c.Call.Return(run)
	return _c
}

// DiskUsage provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) DiskUsage(ctx context.Context, options types.DiskUsageOptions) (types.DiskUsage, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for DiskUsage")
	}

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

// MockAPIClient_DiskUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskUsage'
type MockAPIClient_DiskUsage_Call struct {
	*mock.Call
}

// DiskUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - options types.DiskUsageOptions
func (_e *MockAPIClient_Expecter) DiskUsage(ctx any, options any) *MockAPIClient_DiskUsage_Call {
	return &MockAPIClient_DiskUsage_Call{Call: _e.mock.On("DiskUsage", ctx, options)}
}

func (_c *MockAPIClient_DiskUsage_Call) Run(run func(ctx context.Context, options types.DiskUsageOptions)) *MockAPIClient_DiskUsage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 types.DiskUsageOptions
		if args[1] != nil {
			arg1 = args[1].(types.DiskUsageOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_DiskUsage_Call) Return(diskUsage types.DiskUsage, err error) *MockAPIClient_DiskUsage_Call {
	_c.Call.Return(diskUsage, err)
	return _c
}

func (_c *MockAPIClient_DiskUsage_Call) RunAndReturn(run func(ctx context.Context, options types.DiskUsageOptions) (types.DiskUsage, error)) *MockAPIClient_DiskUsage_Call {
	_c.Call.Return(run)
	return _c
}

// DistributionInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) DistributionInspect(ctx context.Context, image string, encodedRegistryAuth string) (registry.DistributionInspect, error) {
	ret := _mock.Called(ctx, image, encodedRegistryAuth)

	if len(ret) == 0 {
		panic("no return value specified for DistributionInspect")
	}

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

// MockAPIClient_DistributionInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DistributionInspect'
type MockAPIClient_DistributionInspect_Call struct {
	*mock.Call
}

// DistributionInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - image string
//   - encodedRegistryAuth string
func (_e *MockAPIClient_Expecter) DistributionInspect(ctx any, image any, encodedRegistryAuth any) *MockAPIClient_DistributionInspect_Call {
	return &MockAPIClient_DistributionInspect_Call{Call: _e.mock.On("DistributionInspect", ctx, image, encodedRegistryAuth)}
}

func (_c *MockAPIClient_DistributionInspect_Call) Run(run func(ctx context.Context, image string, encodedRegistryAuth string)) *MockAPIClient_DistributionInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_DistributionInspect_Call) Return(distributionInspect registry.DistributionInspect, err error) *MockAPIClient_DistributionInspect_Call {
	_c.Call.Return(distributionInspect, err)
	return _c
}

func (_c *MockAPIClient_DistributionInspect_Call) RunAndReturn(run func(ctx context.Context, image string, encodedRegistryAuth string) (registry.DistributionInspect, error)) *MockAPIClient_DistributionInspect_Call {
	_c.Call.Return(run)
	return _c
}

// Events provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) Events(ctx context.Context, options events.ListOptions) (<-chan events.Message, <-chan error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for Events")
	}

	var r0 <-chan events.Message
	var r1 <-chan error
	if returnFunc, ok := ret.Get(0).(func(context.Context, events.ListOptions) (<-chan events.Message, <-chan error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, events.ListOptions) <-chan events.Message); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan events.Message)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, events.ListOptions) <-chan error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(<-chan error)
		}
	}
	return r0, r1
}

// MockAPIClient_Events_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Events'
type MockAPIClient_Events_Call struct {
	*mock.Call
}

// Events is a helper method to define mock.On call
//   - ctx context.Context
//   - options events.ListOptions
func (_e *MockAPIClient_Expecter) Events(ctx any, options any) *MockAPIClient_Events_Call {
	return &MockAPIClient_Events_Call{Call: _e.mock.On("Events", ctx, options)}
}

func (_c *MockAPIClient_Events_Call) Run(run func(ctx context.Context, options events.ListOptions)) *MockAPIClient_Events_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 events.ListOptions
		if args[1] != nil {
			arg1 = args[1].(events.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_Events_Call) Return(messageCh <-chan events.Message, errCh <-chan error) *MockAPIClient_Events_Call {
	_c.Call.Return(messageCh, errCh)
	return _c
}

func (_c *MockAPIClient_Events_Call) RunAndReturn(run func(ctx context.Context, options events.ListOptions) (<-chan events.Message, <-chan error)) *MockAPIClient_Events_Call {
	_c.Call.Return(run)
	return _c
}

// HTTPClient provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) HTTPClient() *http.Client {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HTTPClient")
	}

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

// MockAPIClient_HTTPClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HTTPClient'
type MockAPIClient_HTTPClient_Call struct {
	*mock.Call
}

// HTTPClient is a helper method to define mock.On call
func (_e *MockAPIClient_Expecter) HTTPClient() *MockAPIClient_HTTPClient_Call {
	return &MockAPIClient_HTTPClient_Call{Call: _e.mock.On("HTTPClient")}
}

func (_c *MockAPIClient_HTTPClient_Call) Run(run func()) *MockAPIClient_HTTPClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockAPIClient_HTTPClient_Call) Return(client *http.Client) *MockAPIClient_HTTPClient_Call {
	_c.Call.Return(client)
	return _c
}

func (_c *MockAPIClient_HTTPClient_Call) RunAndReturn(run func() *http.Client) *MockAPIClient_HTTPClient_Call {
	_c.Call.Return(run)
	return _c
}

// ImageBuild provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageBuild(ctx context.Context, context1 io.Reader, options build.ImageBuildOptions) (build.ImageBuildResponse, error) {
	ret := _mock.Called(ctx, context1, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageBuild")
	}

	var r0 build.ImageBuildResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, build.ImageBuildOptions) (build.ImageBuildResponse, error)); ok {
		return returnFunc(ctx, context1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, build.ImageBuildOptions) build.ImageBuildResponse); ok {
		r0 = returnFunc(ctx, context1, options)
	} else {
		r0 = ret.Get(0).(build.ImageBuildResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, build.ImageBuildOptions) error); ok {
		r1 = returnFunc(ctx, context1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageBuild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageBuild'
type MockAPIClient_ImageBuild_Call struct {
	*mock.Call
}

// ImageBuild is a helper method to define mock.On call
//   - ctx context.Context
//   - context1 io.Reader
//   - options build.ImageBuildOptions
func (_e *MockAPIClient_Expecter) ImageBuild(ctx any, context1 any, options any) *MockAPIClient_ImageBuild_Call {
	return &MockAPIClient_ImageBuild_Call{Call: _e.mock.On("ImageBuild", ctx, context1, options)}
}

func (_c *MockAPIClient_ImageBuild_Call) Run(run func(ctx context.Context, context1 io.Reader, options build.ImageBuildOptions)) *MockAPIClient_ImageBuild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 build.ImageBuildOptions
		if args[2] != nil {
			arg2 = args[2].(build.ImageBuildOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageBuild_Call) Return(imageBuildResponse build.ImageBuildResponse, err error) *MockAPIClient_ImageBuild_Call {
	_c.Call.Return(imageBuildResponse, err)
	return _c
}

func (_c *MockAPIClient_ImageBuild_Call) RunAndReturn(run func(ctx context.Context, context1 io.Reader, options build.ImageBuildOptions) (build.ImageBuildResponse, error)) *MockAPIClient_ImageBuild_Call {
	_c.Call.Return(run)
	return _c
}

// ImageCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageCreate(ctx context.Context, parentReference string, options image.CreateOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, parentReference, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageCreate")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.CreateOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, parentReference, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.CreateOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, parentReference, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, image.CreateOptions) error); ok {
		r1 = returnFunc(ctx, parentReference, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageCreate'
type MockAPIClient_ImageCreate_Call struct {
	*mock.Call
}

// ImageCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - parentReference string
//   - options image.CreateOptions
func (_e *MockAPIClient_Expecter) ImageCreate(ctx any, parentReference any, options any) *MockAPIClient_ImageCreate_Call {
	return &MockAPIClient_ImageCreate_Call{Call: _e.mock.On("ImageCreate", ctx, parentReference, options)}
}

func (_c *MockAPIClient_ImageCreate_Call) Run(run func(ctx context.Context, parentReference string, options image.CreateOptions)) *MockAPIClient_ImageCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 image.CreateOptions
		if args[2] != nil {
			arg2 = args[2].(image.CreateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageCreate_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageCreate_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ImageCreate_Call) RunAndReturn(run func(ctx context.Context, parentReference string, options image.CreateOptions) (io.ReadCloser, error)) *MockAPIClient_ImageCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ImageHistory provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageHistory(ctx context.Context, image1 string, imageHistoryOptions ...client.ImageHistoryOption) ([]image.HistoryResponseItem, error) {
	var tmpRet mock.Arguments
	if len(imageHistoryOptions) > 0 {
		tmpRet = _mock.Called(ctx, image1, imageHistoryOptions)
	} else {
		tmpRet = _mock.Called(ctx, image1)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ImageHistory")
	}

	var r0 []image.HistoryResponseItem
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...client.ImageHistoryOption) ([]image.HistoryResponseItem, error)); ok {
		return returnFunc(ctx, image1, imageHistoryOptions...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...client.ImageHistoryOption) []image.HistoryResponseItem); ok {
		r0 = returnFunc(ctx, image1, imageHistoryOptions...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]image.HistoryResponseItem)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ...client.ImageHistoryOption) error); ok {
		r1 = returnFunc(ctx, image1, imageHistoryOptions...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageHistory'
type MockAPIClient_ImageHistory_Call struct {
	*mock.Call
}

// ImageHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - image1 string
//   - imageHistoryOptions ...client.ImageHistoryOption
func (_e *MockAPIClient_Expecter) ImageHistory(ctx any, image1 any, imageHistoryOptions ...any) *MockAPIClient_ImageHistory_Call {
	return &MockAPIClient_ImageHistory_Call{Call: _e.mock.On("ImageHistory",
		append([]any{ctx, image1}, imageHistoryOptions...)...)}
}

func (_c *MockAPIClient_ImageHistory_Call) Run(run func(ctx context.Context, image1 string, imageHistoryOptions ...client.ImageHistoryOption)) *MockAPIClient_ImageHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []client.ImageHistoryOption
		var variadicArgs []client.ImageHistoryOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ImageHistoryOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageHistory_Call) Return(historyResponseItems []image.HistoryResponseItem, err error) *MockAPIClient_ImageHistory_Call {
	_c.Call.Return(historyResponseItems, err)
	return _c
}

func (_c *MockAPIClient_ImageHistory_Call) RunAndReturn(run func(ctx context.Context, image1 string, imageHistoryOptions ...client.ImageHistoryOption) ([]image.HistoryResponseItem, error)) *MockAPIClient_ImageHistory_Call {
	_c.Call.Return(run)
	return _c
}

// ImageImport provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageImport(ctx context.Context, source image.ImportSource, ref string, options image.ImportOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, source, ref, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageImport")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, image.ImportSource, string, image.ImportOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, source, ref, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, image.ImportSource, string, image.ImportOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, source, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, image.ImportSource, string, image.ImportOptions) error); ok {
		r1 = returnFunc(ctx, source, ref, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageImport'
type MockAPIClient_ImageImport_Call struct {
	*mock.Call
}

// ImageImport is a helper method to define mock.On call
//   - ctx context.Context
//   - source image.ImportSource
//   - ref string
//   - options image.ImportOptions
func (_e *MockAPIClient_Expecter) ImageImport(ctx any, source any, ref any, options any) *MockAPIClient_ImageImport_Call {
	return &MockAPIClient_ImageImport_Call{Call: _e.mock.On("ImageImport", ctx, source, ref, options)}
}

func (_c *MockAPIClient_ImageImport_Call) Run(run func(ctx context.Context, source image.ImportSource, ref string, options image.ImportOptions)) *MockAPIClient_ImageImport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 image.ImportSource
		if args[1] != nil {
			arg1 = args[1].(image.ImportSource)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 image.ImportOptions
		if args[3] != nil {
			arg3 = args[3].(image.ImportOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageImport_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageImport_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ImageImport_Call) RunAndReturn(run func(ctx context.Context, source image.ImportSource, ref string, options image.ImportOptions) (io.ReadCloser, error)) *MockAPIClient_ImageImport_Call {
	_c.Call.Return(run)
	return _c
}

// ImageInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageInspect(ctx context.Context, image1 string, imageInspectOptions ...client.ImageInspectOption) (image.InspectResponse, error) {
	var tmpRet mock.Arguments
	if len(imageInspectOptions) > 0 {
		tmpRet = _mock.Called(ctx, image1, imageInspectOptions)
	} else {
		tmpRet = _mock.Called(ctx, image1)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ImageInspect")
	}

	var r0 image.InspectResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...client.ImageInspectOption) (image.InspectResponse, error)); ok {
		return returnFunc(ctx, image1, imageInspectOptions...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...client.ImageInspectOption) image.InspectResponse); ok {
		r0 = returnFunc(ctx, image1, imageInspectOptions...)
	} else {
		r0 = ret.Get(0).(image.InspectResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ...client.ImageInspectOption) error); ok {
		r1 = returnFunc(ctx, image1, imageInspectOptions...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageInspect'
type MockAPIClient_ImageInspect_Call struct {
	*mock.Call
}

// ImageInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - image1 string
//   - imageInspectOptions ...client.ImageInspectOption
func (_e *MockAPIClient_Expecter) ImageInspect(ctx any, image1 any, imageInspectOptions ...any) *MockAPIClient_ImageInspect_Call {
	return &MockAPIClient_ImageInspect_Call{Call: _e.mock.On("ImageInspect",
		append([]any{ctx, image1}, imageInspectOptions...)...)}
}

func (_c *MockAPIClient_ImageInspect_Call) Run(run func(ctx context.Context, image1 string, imageInspectOptions ...client.ImageInspectOption)) *MockAPIClient_ImageInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []client.ImageInspectOption
		var variadicArgs []client.ImageInspectOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ImageInspectOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageInspect_Call) Return(inspectResponse image.InspectResponse, err error) *MockAPIClient_ImageInspect_Call {
	_c.Call.Return(inspectResponse, err)
	return _c
}

func (_c *MockAPIClient_ImageInspect_Call) RunAndReturn(run func(ctx context.Context, image1 string, imageInspectOptions ...client.ImageInspectOption) (image.InspectResponse, error)) *MockAPIClient_ImageInspect_Call {
	_c.Call.Return(run)
	return _c
}

// ImageInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageInspectWithRaw(ctx context.Context, image1 string) (image.InspectResponse, []byte, error) {
	ret := _mock.Called(ctx, image1)

	if len(ret) == 0 {
		panic("no return value specified for ImageInspectWithRaw")
	}

	var r0 image.InspectResponse
	var r1 []byte
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (image.InspectResponse, []byte, error)); ok {
		return returnFunc(ctx, image1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) image.InspectResponse); ok {
		r0 = returnFunc(ctx, image1)
	} else {
		r0 = ret.Get(0).(image.InspectResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = returnFunc(ctx, image1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = returnFunc(ctx, image1)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockAPIClient_ImageInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageInspectWithRaw'
type MockAPIClient_ImageInspectWithRaw_Call struct {
	*mock.Call
}

// ImageInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - image1 string
func (_e *MockAPIClient_Expecter) ImageInspectWithRaw(ctx any, image1 any) *MockAPIClient_ImageInspectWithRaw_Call {
	return &MockAPIClient_ImageInspectWithRaw_Call{Call: _e.mock.On("ImageInspectWithRaw", ctx, image1)}
}

func (_c *MockAPIClient_ImageInspectWithRaw_Call) Run(run func(ctx context.Context, image1 string)) *MockAPIClient_ImageInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageInspectWithRaw_Call) Return(inspectResponse image.InspectResponse, bytes []byte, err error) *MockAPIClient_ImageInspectWithRaw_Call {
	_c.Call.Return(inspectResponse, bytes, err)
	return _c
}

func (_c *MockAPIClient_ImageInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, image1 string) (image.InspectResponse, []byte, error)) *MockAPIClient_ImageInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// ImageList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageList(ctx context.Context, options image.ListOptions) ([]image.Summary, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageList")
	}

	var r0 []image.Summary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, image.ListOptions) ([]image.Summary, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, image.ListOptions) []image.Summary); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]image.Summary)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, image.ListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageList'
type MockAPIClient_ImageList_Call struct {
	*mock.Call
}

// ImageList is a helper method to define mock.On call
//   - ctx context.Context
//   - options image.ListOptions
func (_e *MockAPIClient_Expecter) ImageList(ctx any, options any) *MockAPIClient_ImageList_Call {
	return &MockAPIClient_ImageList_Call{Call: _e.mock.On("ImageList", ctx, options)}
}

func (_c *MockAPIClient_ImageList_Call) Run(run func(ctx context.Context, options image.ListOptions)) *MockAPIClient_ImageList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 image.ListOptions
		if args[1] != nil {
			arg1 = args[1].(image.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageList_Call) Return(summarys []image.Summary, err error) *MockAPIClient_ImageList_Call {
	_c.Call.Return(summarys, err)
	return _c
}

func (_c *MockAPIClient_ImageList_Call) RunAndReturn(run func(ctx context.Context, options image.ListOptions) ([]image.Summary, error)) *MockAPIClient_ImageList_Call {
	_c.Call.Return(run)
	return _c
}

// ImageLoad provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageLoad(ctx context.Context, input io.Reader, imageLoadOptions ...client.ImageLoadOption) (image.LoadResponse, error) {
	var tmpRet mock.Arguments
	if len(imageLoadOptions) > 0 {
		tmpRet = _mock.Called(ctx, input, imageLoadOptions)
	} else {
		tmpRet = _mock.Called(ctx, input)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ImageLoad")
	}

	var r0 image.LoadResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, ...client.ImageLoadOption) (image.LoadResponse, error)); ok {
		return returnFunc(ctx, input, imageLoadOptions...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, ...client.ImageLoadOption) image.LoadResponse); ok {
		r0 = returnFunc(ctx, input, imageLoadOptions...)
	} else {
		r0 = ret.Get(0).(image.LoadResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, ...client.ImageLoadOption) error); ok {
		r1 = returnFunc(ctx, input, imageLoadOptions...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageLoad'
type MockAPIClient_ImageLoad_Call struct {
	*mock.Call
}

// ImageLoad is a helper method to define mock.On call
//   - ctx context.Context
//   - input io.Reader
//   - imageLoadOptions ...client.ImageLoadOption
func (_e *MockAPIClient_Expecter) ImageLoad(ctx any, input any, imageLoadOptions ...any) *MockAPIClient_ImageLoad_Call {
	return &MockAPIClient_ImageLoad_Call{Call: _e.mock.On("ImageLoad",
		append([]any{ctx, input}, imageLoadOptions...)...)}
}

func (_c *MockAPIClient_ImageLoad_Call) Run(run func(ctx context.Context, input io.Reader, imageLoadOptions ...client.ImageLoadOption)) *MockAPIClient_ImageLoad_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 []client.ImageLoadOption
		var variadicArgs []client.ImageLoadOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ImageLoadOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageLoad_Call) Return(loadResponse image.LoadResponse, err error) *MockAPIClient_ImageLoad_Call {
	_c.Call.Return(loadResponse, err)
	return _c
}

func (_c *MockAPIClient_ImageLoad_Call) RunAndReturn(run func(ctx context.Context, input io.Reader, imageLoadOptions ...client.ImageLoadOption) (image.LoadResponse, error)) *MockAPIClient_ImageLoad_Call {
	_c.Call.Return(run)
	return _c
}

// ImagePull provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImagePull(ctx context.Context, ref string, options image.PullOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, ref, options)

	if len(ret) == 0 {
		panic("no return value specified for ImagePull")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.PullOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, ref, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.PullOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, image.PullOptions) error); ok {
		r1 = returnFunc(ctx, ref, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImagePull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImagePull'
type MockAPIClient_ImagePull_Call struct {
	*mock.Call
}

// ImagePull is a helper method to define mock.On call
//   - ctx context.Context
//   - ref string
//   - options image.PullOptions
func (_e *MockAPIClient_Expecter) ImagePull(ctx any, ref any, options any) *MockAPIClient_ImagePull_Call {
	return &MockAPIClient_ImagePull_Call{Call: _e.mock.On("ImagePull", ctx, ref, options)}
}

func (_c *MockAPIClient_ImagePull_Call) Run(run func(ctx context.Context, ref string, options image.PullOptions)) *MockAPIClient_ImagePull_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 image.PullOptions
		if args[2] != nil {
			arg2 = args[2].(image.PullOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImagePull_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImagePull_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ImagePull_Call) RunAndReturn(run func(ctx context.Context, ref string, options image.PullOptions) (io.ReadCloser, error)) *MockAPIClient_ImagePull_Call {
	_c.Call.Return(run)
	return _c
}

// ImagePush provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImagePush(ctx context.Context, ref string, options image.PushOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, ref, options)

	if len(ret) == 0 {
		panic("no return value specified for ImagePush")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.PushOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, ref, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.PushOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, ref, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, image.PushOptions) error); ok {
		r1 = returnFunc(ctx, ref, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImagePush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImagePush'
type MockAPIClient_ImagePush_Call struct {
	*mock.Call
}

// ImagePush is a helper method to define mock.On call
//   - ctx context.Context
//   - ref string
//   - options image.PushOptions
func (_e *MockAPIClient_Expecter) ImagePush(ctx any, ref any, options any) *MockAPIClient_ImagePush_Call {
	return &MockAPIClient_ImagePush_Call{Call: _e.mock.On("ImagePush", ctx, ref, options)}
}

func (_c *MockAPIClient_ImagePush_Call) Run(run func(ctx context.Context, ref string, options image.PushOptions)) *MockAPIClient_ImagePush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 image.PushOptions
		if args[2] != nil {
			arg2 = args[2].(image.PushOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImagePush_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImagePush_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ImagePush_Call) RunAndReturn(run func(ctx context.Context, ref string, options image.PushOptions) (io.ReadCloser, error)) *MockAPIClient_ImagePush_Call {
	_c.Call.Return(run)
	return _c
}

// ImageRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageRemove(ctx context.Context, image1 string, options image.RemoveOptions) ([]image.DeleteResponse, error) {
	ret := _mock.Called(ctx, image1, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageRemove")
	}

	var r0 []image.DeleteResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.RemoveOptions) ([]image.DeleteResponse, error)); ok {
		return returnFunc(ctx, image1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, image.RemoveOptions) []image.DeleteResponse); ok {
		r0 = returnFunc(ctx, image1, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]image.DeleteResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, image.RemoveOptions) error); ok {
		r1 = returnFunc(ctx, image1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageRemove'
type MockAPIClient_ImageRemove_Call struct {
	*mock.Call
}

// ImageRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - image1 string
//   - options image.RemoveOptions
func (_e *MockAPIClient_Expecter) ImageRemove(ctx any, image1 any, options any) *MockAPIClient_ImageRemove_Call {
	return &MockAPIClient_ImageRemove_Call{Call: _e.mock.On("ImageRemove", ctx, image1, options)}
}

func (_c *MockAPIClient_ImageRemove_Call) Run(run func(ctx context.Context, image1 string, options image.RemoveOptions)) *MockAPIClient_ImageRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 image.RemoveOptions
		if args[2] != nil {
			arg2 = args[2].(image.RemoveOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageRemove_Call) Return(deleteResponses []image.DeleteResponse, err error) *MockAPIClient_ImageRemove_Call {
	_c.Call.Return(deleteResponses, err)
	return _c
}

func (_c *MockAPIClient_ImageRemove_Call) RunAndReturn(run func(ctx context.Context, image1 string, options image.RemoveOptions) ([]image.DeleteResponse, error)) *MockAPIClient_ImageRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ImageSave provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageSave(ctx context.Context, images []string, imageSaveOptions ...client.ImageSaveOption) (io.ReadCloser, error) {
	var tmpRet mock.Arguments
	if len(imageSaveOptions) > 0 {
		tmpRet = _mock.Called(ctx, images, imageSaveOptions)
	} else {
		tmpRet = _mock.Called(ctx, images)
	}
	ret := tmpRet

	if len(ret) == 0 {
		panic("no return value specified for ImageSave")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, ...client.ImageSaveOption) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, images, imageSaveOptions...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, ...client.ImageSaveOption) io.ReadCloser); ok {
		r0 = returnFunc(ctx, images, imageSaveOptions...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, ...client.ImageSaveOption) error); ok {
		r1 = returnFunc(ctx, images, imageSaveOptions...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageSave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageSave'
type MockAPIClient_ImageSave_Call struct {
	*mock.Call
}

// ImageSave is a helper method to define mock.On call
//   - ctx context.Context
//   - images []string
//   - imageSaveOptions ...client.ImageSaveOption
func (_e *MockAPIClient_Expecter) ImageSave(ctx any, images any, imageSaveOptions ...any) *MockAPIClient_ImageSave_Call {
	return &MockAPIClient_ImageSave_Call{Call: _e.mock.On("ImageSave",
		append([]any{ctx, images}, imageSaveOptions...)...)}
}

func (_c *MockAPIClient_ImageSave_Call) Run(run func(ctx context.Context, images []string, imageSaveOptions ...client.ImageSaveOption)) *MockAPIClient_ImageSave_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 []client.ImageSaveOption
		var variadicArgs []client.ImageSaveOption
		if len(args) > 2 {
			variadicArgs = args[2].([]client.ImageSaveOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageSave_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ImageSave_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ImageSave_Call) RunAndReturn(run func(ctx context.Context, images []string, imageSaveOptions ...client.ImageSaveOption) (io.ReadCloser, error)) *MockAPIClient_ImageSave_Call {
	_c.Call.Return(run)
	return _c
}

// ImageSearch provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageSearch(ctx context.Context, term string, options registry.SearchOptions) ([]registry.SearchResult, error) {
	ret := _mock.Called(ctx, term, options)

	if len(ret) == 0 {
		panic("no return value specified for ImageSearch")
	}

	var r0 []registry.SearchResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, registry.SearchOptions) ([]registry.SearchResult, error)); ok {
		return returnFunc(ctx, term, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, registry.SearchOptions) []registry.SearchResult); ok {
		r0 = returnFunc(ctx, term, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]registry.SearchResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, registry.SearchOptions) error); ok {
		r1 = returnFunc(ctx, term, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImageSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageSearch'
type MockAPIClient_ImageSearch_Call struct {
	*mock.Call
}

// ImageSearch is a helper method to define mock.On call
//   - ctx context.Context
//   - term string
//   - options registry.SearchOptions
func (_e *MockAPIClient_Expecter) ImageSearch(ctx any, term any, options any) *MockAPIClient_ImageSearch_Call {
	return &MockAPIClient_ImageSearch_Call{Call: _e.mock.On("ImageSearch", ctx, term, options)}
}

func (_c *MockAPIClient_ImageSearch_Call) Run(run func(ctx context.Context, term string, options registry.SearchOptions)) *MockAPIClient_ImageSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 registry.SearchOptions
		if args[2] != nil {
			arg2 = args[2].(registry.SearchOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageSearch_Call) Return(searchResults []registry.SearchResult, err error) *MockAPIClient_ImageSearch_Call {
	_c.Call.Return(searchResults, err)
	return _c
}

func (_c *MockAPIClient_ImageSearch_Call) RunAndReturn(run func(ctx context.Context, term string, options registry.SearchOptions) ([]registry.SearchResult, error)) *MockAPIClient_ImageSearch_Call {
	_c.Call.Return(run)
	return _c
}

// ImageTag provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImageTag(ctx context.Context, image1 string, ref string) error {
	ret := _mock.Called(ctx, image1, ref)

	if len(ret) == 0 {
		panic("no return value specified for ImageTag")
	}

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

// MockAPIClient_ImageTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageTag'
type MockAPIClient_ImageTag_Call struct {
	*mock.Call
}

// ImageTag is a helper method to define mock.On call
//   - ctx context.Context
//   - image1 string
//   - ref string
func (_e *MockAPIClient_Expecter) ImageTag(ctx any, image1 any, ref any) *MockAPIClient_ImageTag_Call {
	return &MockAPIClient_ImageTag_Call{Call: _e.mock.On("ImageTag", ctx, image1, ref)}
}

func (_c *MockAPIClient_ImageTag_Call) Run(run func(ctx context.Context, image1 string, ref string)) *MockAPIClient_ImageTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImageTag_Call) Return(err error) *MockAPIClient_ImageTag_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ImageTag_Call) RunAndReturn(run func(ctx context.Context, image1 string, ref string) error) *MockAPIClient_ImageTag_Call {
	_c.Call.Return(run)
	return _c
}

// ImagesPrune provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ImagesPrune(ctx context.Context, pruneFilter filters.Args) (image.PruneReport, error) {
	ret := _mock.Called(ctx, pruneFilter)

	if len(ret) == 0 {
		panic("no return value specified for ImagesPrune")
	}

	var r0 image.PruneReport
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) (image.PruneReport, error)); ok {
		return returnFunc(ctx, pruneFilter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) image.PruneReport); ok {
		r0 = returnFunc(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(image.PruneReport)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = returnFunc(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ImagesPrune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImagesPrune'
type MockAPIClient_ImagesPrune_Call struct {
	*mock.Call
}

// ImagesPrune is a helper method to define mock.On call
//   - ctx context.Context
//   - pruneFilter filters.Args
func (_e *MockAPIClient_Expecter) ImagesPrune(ctx any, pruneFilter any) *MockAPIClient_ImagesPrune_Call {
	return &MockAPIClient_ImagesPrune_Call{Call: _e.mock.On("ImagesPrune", ctx, pruneFilter)}
}

func (_c *MockAPIClient_ImagesPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_ImagesPrune_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 filters.Args
		if args[1] != nil {
			arg1 = args[1].(filters.Args)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ImagesPrune_Call) Return(pruneReport image.PruneReport, err error) *MockAPIClient_ImagesPrune_Call {
	_c.Call.Return(pruneReport, err)
	return _c
}

func (_c *MockAPIClient_ImagesPrune_Call) RunAndReturn(run func(ctx context.Context, pruneFilter filters.Args) (image.PruneReport, error)) *MockAPIClient_ImagesPrune_Call {
	_c.Call.Return(run)
	return _c
}

// Info provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) Info(ctx context.Context) (system.Info, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Info")
	}

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

// MockAPIClient_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
type MockAPIClient_Info_Call struct {
	*mock.Call
}

// Info is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) Info(ctx any) *MockAPIClient_Info_Call {
	return &MockAPIClient_Info_Call{Call: _e.mock.On("Info", ctx)}
}

func (_c *MockAPIClient_Info_Call) Run(run func(ctx context.Context)) *MockAPIClient_Info_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_Info_Call) Return(info system.Info, err error) *MockAPIClient_Info_Call {
	_c.Call.Return(info, err)
	return _c
}

func (_c *MockAPIClient_Info_Call) RunAndReturn(run func(ctx context.Context) (system.Info, error)) *MockAPIClient_Info_Call {
	_c.Call.Return(run)
	return _c
}

// NegotiateAPIVersion provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NegotiateAPIVersion(ctx context.Context) {
	_mock.Called(ctx)
	return
}

// MockAPIClient_NegotiateAPIVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NegotiateAPIVersion'
type MockAPIClient_NegotiateAPIVersion_Call struct {
	*mock.Call
}

// NegotiateAPIVersion is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) NegotiateAPIVersion(ctx any) *MockAPIClient_NegotiateAPIVersion_Call {
	return &MockAPIClient_NegotiateAPIVersion_Call{Call: _e.mock.On("NegotiateAPIVersion", ctx)}
}

func (_c *MockAPIClient_NegotiateAPIVersion_Call) Run(run func(ctx context.Context)) *MockAPIClient_NegotiateAPIVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_NegotiateAPIVersion_Call) Return() *MockAPIClient_NegotiateAPIVersion_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockAPIClient_NegotiateAPIVersion_Call) RunAndReturn(run func(ctx context.Context)) *MockAPIClient_NegotiateAPIVersion_Call {
	_c.Run(run)
	return _c
}

// NegotiateAPIVersionPing provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NegotiateAPIVersionPing(ping types.Ping) {
	_mock.Called(ping)
	return
}

// MockAPIClient_NegotiateAPIVersionPing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NegotiateAPIVersionPing'
type MockAPIClient_NegotiateAPIVersionPing_Call struct {
	*mock.Call
}

// NegotiateAPIVersionPing is a helper method to define mock.On call
//   - ping types.Ping
func (_e *MockAPIClient_Expecter) NegotiateAPIVersionPing(ping any) *MockAPIClient_NegotiateAPIVersionPing_Call {
	return &MockAPIClient_NegotiateAPIVersionPing_Call{Call: _e.mock.On("NegotiateAPIVersionPing", ping)}
}

func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) Run(run func(ping types.Ping)) *MockAPIClient_NegotiateAPIVersionPing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 types.Ping
		if args[0] != nil {
			arg0 = args[0].(types.Ping)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) Return() *MockAPIClient_NegotiateAPIVersionPing_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockAPIClient_NegotiateAPIVersionPing_Call) RunAndReturn(run func(ping types.Ping)) *MockAPIClient_NegotiateAPIVersionPing_Call {
	_c.Run(run)
	return _c
}

// NetworkConnect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkConnect(ctx context.Context, network1 string, container1 string, config *network.EndpointSettings) error {
	ret := _mock.Called(ctx, network1, container1, config)

	if len(ret) == 0 {
		panic("no return value specified for NetworkConnect")
	}

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

// MockAPIClient_NetworkConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkConnect'
type MockAPIClient_NetworkConnect_Call struct {
	*mock.Call
}

// NetworkConnect is a helper method to define mock.On call
//   - ctx context.Context
//   - network1 string
//   - container1 string
//   - config *network.EndpointSettings
func (_e *MockAPIClient_Expecter) NetworkConnect(ctx any, network1 any, container1 any, config any) *MockAPIClient_NetworkConnect_Call {
	return &MockAPIClient_NetworkConnect_Call{Call: _e.mock.On("NetworkConnect", ctx, network1, container1, config)}
}

func (_c *MockAPIClient_NetworkConnect_Call) Run(run func(ctx context.Context, network1 string, container1 string, config *network.EndpointSettings)) *MockAPIClient_NetworkConnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 *network.EndpointSettings
		if args[3] != nil {
			arg3 = args[3].(*network.EndpointSettings)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkConnect_Call) Return(err error) *MockAPIClient_NetworkConnect_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_NetworkConnect_Call) RunAndReturn(run func(ctx context.Context, network1 string, container1 string, config *network.EndpointSettings) error) *MockAPIClient_NetworkConnect_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkCreate(ctx context.Context, name string, options network.CreateOptions) (network.CreateResponse, error) {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for NetworkCreate")
	}

	var r0 network.CreateResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.CreateOptions) (network.CreateResponse, error)); ok {
		return returnFunc(ctx, name, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.CreateOptions) network.CreateResponse); ok {
		r0 = returnFunc(ctx, name, options)
	} else {
		r0 = ret.Get(0).(network.CreateResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, network.CreateOptions) error); ok {
		r1 = returnFunc(ctx, name, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_NetworkCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkCreate'
type MockAPIClient_NetworkCreate_Call struct {
	*mock.Call
}

// NetworkCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options network.CreateOptions
func (_e *MockAPIClient_Expecter) NetworkCreate(ctx any, name any, options any) *MockAPIClient_NetworkCreate_Call {
	return &MockAPIClient_NetworkCreate_Call{Call: _e.mock.On("NetworkCreate", ctx, name, options)}
}

func (_c *MockAPIClient_NetworkCreate_Call) Run(run func(ctx context.Context, name string, options network.CreateOptions)) *MockAPIClient_NetworkCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 network.CreateOptions
		if args[2] != nil {
			arg2 = args[2].(network.CreateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkCreate_Call) Return(createResponse network.CreateResponse, err error) *MockAPIClient_NetworkCreate_Call {
	_c.Call.Return(createResponse, err)
	return _c
}

func (_c *MockAPIClient_NetworkCreate_Call) RunAndReturn(run func(ctx context.Context, name string, options network.CreateOptions) (network.CreateResponse, error)) *MockAPIClient_NetworkCreate_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkDisconnect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkDisconnect(ctx context.Context, network1 string, container1 string, force bool) error {
	ret := _mock.Called(ctx, network1, container1, force)

	if len(ret) == 0 {
		panic("no return value specified for NetworkDisconnect")
	}

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

// MockAPIClient_NetworkDisconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkDisconnect'
type MockAPIClient_NetworkDisconnect_Call struct {
	*mock.Call
}

// NetworkDisconnect is a helper method to define mock.On call
//   - ctx context.Context
//   - network1 string
//   - container1 string
//   - force bool
func (_e *MockAPIClient_Expecter) NetworkDisconnect(ctx any, network1 any, container1 any, force any) *MockAPIClient_NetworkDisconnect_Call {
	return &MockAPIClient_NetworkDisconnect_Call{Call: _e.mock.On("NetworkDisconnect", ctx, network1, container1, force)}
}

func (_c *MockAPIClient_NetworkDisconnect_Call) Run(run func(ctx context.Context, network1 string, container1 string, force bool)) *MockAPIClient_NetworkDisconnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 bool
		if args[3] != nil {
			arg3 = args[3].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkDisconnect_Call) Return(err error) *MockAPIClient_NetworkDisconnect_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_NetworkDisconnect_Call) RunAndReturn(run func(ctx context.Context, network1 string, container1 string, force bool) error) *MockAPIClient_NetworkDisconnect_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkInspect(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, error) {
	ret := _mock.Called(ctx, network1, options)

	if len(ret) == 0 {
		panic("no return value specified for NetworkInspect")
	}

	var r0 network.Inspect
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.InspectOptions) (network.Inspect, error)); ok {
		return returnFunc(ctx, network1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.InspectOptions) network.Inspect); ok {
		r0 = returnFunc(ctx, network1, options)
	} else {
		r0 = ret.Get(0).(network.Inspect)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, network.InspectOptions) error); ok {
		r1 = returnFunc(ctx, network1, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_NetworkInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkInspect'
type MockAPIClient_NetworkInspect_Call struct {
	*mock.Call
}

// NetworkInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - network1 string
//   - options network.InspectOptions
func (_e *MockAPIClient_Expecter) NetworkInspect(ctx any, network1 any, options any) *MockAPIClient_NetworkInspect_Call {
	return &MockAPIClient_NetworkInspect_Call{Call: _e.mock.On("NetworkInspect", ctx, network1, options)}
}

func (_c *MockAPIClient_NetworkInspect_Call) Run(run func(ctx context.Context, network1 string, options network.InspectOptions)) *MockAPIClient_NetworkInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 network.InspectOptions
		if args[2] != nil {
			arg2 = args[2].(network.InspectOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkInspect_Call) Return(inspect network.Inspect, err error) *MockAPIClient_NetworkInspect_Call {
	_c.Call.Return(inspect, err)
	return _c
}

func (_c *MockAPIClient_NetworkInspect_Call) RunAndReturn(run func(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, error)) *MockAPIClient_NetworkInspect_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkInspectWithRaw(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, []byte, error) {
	ret := _mock.Called(ctx, network1, options)

	if len(ret) == 0 {
		panic("no return value specified for NetworkInspectWithRaw")
	}

	var r0 network.Inspect
	var r1 []byte
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.InspectOptions) (network.Inspect, []byte, error)); ok {
		return returnFunc(ctx, network1, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, network.InspectOptions) network.Inspect); ok {
		r0 = returnFunc(ctx, network1, options)
	} else {
		r0 = ret.Get(0).(network.Inspect)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, network.InspectOptions) []byte); ok {
		r1 = returnFunc(ctx, network1, options)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string, network.InspectOptions) error); ok {
		r2 = returnFunc(ctx, network1, options)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockAPIClient_NetworkInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkInspectWithRaw'
type MockAPIClient_NetworkInspectWithRaw_Call struct {
	*mock.Call
}

// NetworkInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - network1 string
//   - options network.InspectOptions
func (_e *MockAPIClient_Expecter) NetworkInspectWithRaw(ctx any, network1 any, options any) *MockAPIClient_NetworkInspectWithRaw_Call {
	return &MockAPIClient_NetworkInspectWithRaw_Call{Call: _e.mock.On("NetworkInspectWithRaw", ctx, network1, options)}
}

func (_c *MockAPIClient_NetworkInspectWithRaw_Call) Run(run func(ctx context.Context, network1 string, options network.InspectOptions)) *MockAPIClient_NetworkInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 network.InspectOptions
		if args[2] != nil {
			arg2 = args[2].(network.InspectOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkInspectWithRaw_Call) Return(inspect network.Inspect, bytes []byte, err error) *MockAPIClient_NetworkInspectWithRaw_Call {
	_c.Call.Return(inspect, bytes, err)
	return _c
}

func (_c *MockAPIClient_NetworkInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, network1 string, options network.InspectOptions) (network.Inspect, []byte, error)) *MockAPIClient_NetworkInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkList(ctx context.Context, options network.ListOptions) ([]network.Summary, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for NetworkList")
	}

	var r0 []network.Summary
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, network.ListOptions) ([]network.Summary, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, network.ListOptions) []network.Summary); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]network.Summary)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, network.ListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_NetworkList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkList'
type MockAPIClient_NetworkList_Call struct {
	*mock.Call
}

// NetworkList is a helper method to define mock.On call
//   - ctx context.Context
//   - options network.ListOptions
func (_e *MockAPIClient_Expecter) NetworkList(ctx any, options any) *MockAPIClient_NetworkList_Call {
	return &MockAPIClient_NetworkList_Call{Call: _e.mock.On("NetworkList", ctx, options)}
}

func (_c *MockAPIClient_NetworkList_Call) Run(run func(ctx context.Context, options network.ListOptions)) *MockAPIClient_NetworkList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 network.ListOptions
		if args[1] != nil {
			arg1 = args[1].(network.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkList_Call) Return(summarys []network.Summary, err error) *MockAPIClient_NetworkList_Call {
	_c.Call.Return(summarys, err)
	return _c
}

func (_c *MockAPIClient_NetworkList_Call) RunAndReturn(run func(ctx context.Context, options network.ListOptions) ([]network.Summary, error)) *MockAPIClient_NetworkList_Call {
	_c.Call.Return(run)
	return _c
}

// NetworkRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworkRemove(ctx context.Context, network1 string) error {
	ret := _mock.Called(ctx, network1)

	if len(ret) == 0 {
		panic("no return value specified for NetworkRemove")
	}

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

// MockAPIClient_NetworkRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworkRemove'
type MockAPIClient_NetworkRemove_Call struct {
	*mock.Call
}

// NetworkRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - network1 string
func (_e *MockAPIClient_Expecter) NetworkRemove(ctx any, network1 any) *MockAPIClient_NetworkRemove_Call {
	return &MockAPIClient_NetworkRemove_Call{Call: _e.mock.On("NetworkRemove", ctx, network1)}
}

func (_c *MockAPIClient_NetworkRemove_Call) Run(run func(ctx context.Context, network1 string)) *MockAPIClient_NetworkRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworkRemove_Call) Return(err error) *MockAPIClient_NetworkRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_NetworkRemove_Call) RunAndReturn(run func(ctx context.Context, network1 string) error) *MockAPIClient_NetworkRemove_Call {
	_c.Call.Return(run)
	return _c
}

// NetworksPrune provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NetworksPrune(ctx context.Context, pruneFilter filters.Args) (network.PruneReport, error) {
	ret := _mock.Called(ctx, pruneFilter)

	if len(ret) == 0 {
		panic("no return value specified for NetworksPrune")
	}

	var r0 network.PruneReport
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) (network.PruneReport, error)); ok {
		return returnFunc(ctx, pruneFilter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) network.PruneReport); ok {
		r0 = returnFunc(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(network.PruneReport)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = returnFunc(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_NetworksPrune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NetworksPrune'
type MockAPIClient_NetworksPrune_Call struct {
	*mock.Call
}

// NetworksPrune is a helper method to define mock.On call
//   - ctx context.Context
//   - pruneFilter filters.Args
func (_e *MockAPIClient_Expecter) NetworksPrune(ctx any, pruneFilter any) *MockAPIClient_NetworksPrune_Call {
	return &MockAPIClient_NetworksPrune_Call{Call: _e.mock.On("NetworksPrune", ctx, pruneFilter)}
}

func (_c *MockAPIClient_NetworksPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_NetworksPrune_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 filters.Args
		if args[1] != nil {
			arg1 = args[1].(filters.Args)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_NetworksPrune_Call) Return(pruneReport network.PruneReport, err error) *MockAPIClient_NetworksPrune_Call {
	_c.Call.Return(pruneReport, err)
	return _c
}

func (_c *MockAPIClient_NetworksPrune_Call) RunAndReturn(run func(ctx context.Context, pruneFilter filters.Args) (network.PruneReport, error)) *MockAPIClient_NetworksPrune_Call {
	_c.Call.Return(run)
	return _c
}

// NodeInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NodeInspectWithRaw(ctx context.Context, nodeID string) (swarm.Node, []byte, error) {
	ret := _mock.Called(ctx, nodeID)

	if len(ret) == 0 {
		panic("no return value specified for NodeInspectWithRaw")
	}

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

// MockAPIClient_NodeInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeInspectWithRaw'
type MockAPIClient_NodeInspectWithRaw_Call struct {
	*mock.Call
}

// NodeInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeID string
func (_e *MockAPIClient_Expecter) NodeInspectWithRaw(ctx any, nodeID any) *MockAPIClient_NodeInspectWithRaw_Call {
	return &MockAPIClient_NodeInspectWithRaw_Call{Call: _e.mock.On("NodeInspectWithRaw", ctx, nodeID)}
}

func (_c *MockAPIClient_NodeInspectWithRaw_Call) Run(run func(ctx context.Context, nodeID string)) *MockAPIClient_NodeInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_NodeInspectWithRaw_Call) Return(node swarm.Node, bytes []byte, err error) *MockAPIClient_NodeInspectWithRaw_Call {
	_c.Call.Return(node, bytes, err)
	return _c
}

func (_c *MockAPIClient_NodeInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, nodeID string) (swarm.Node, []byte, error)) *MockAPIClient_NodeInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// NodeList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NodeList(ctx context.Context, options swarm.NodeListOptions) ([]swarm.Node, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for NodeList")
	}

	var r0 []swarm.Node
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.NodeListOptions) ([]swarm.Node, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.NodeListOptions) []swarm.Node); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Node)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, swarm.NodeListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_NodeList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeList'
type MockAPIClient_NodeList_Call struct {
	*mock.Call
}

// NodeList is a helper method to define mock.On call
//   - ctx context.Context
//   - options swarm.NodeListOptions
func (_e *MockAPIClient_Expecter) NodeList(ctx any, options any) *MockAPIClient_NodeList_Call {
	return &MockAPIClient_NodeList_Call{Call: _e.mock.On("NodeList", ctx, options)}
}

func (_c *MockAPIClient_NodeList_Call) Run(run func(ctx context.Context, options swarm.NodeListOptions)) *MockAPIClient_NodeList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.NodeListOptions
		if args[1] != nil {
			arg1 = args[1].(swarm.NodeListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_NodeList_Call) Return(nodes []swarm.Node, err error) *MockAPIClient_NodeList_Call {
	_c.Call.Return(nodes, err)
	return _c
}

func (_c *MockAPIClient_NodeList_Call) RunAndReturn(run func(ctx context.Context, options swarm.NodeListOptions) ([]swarm.Node, error)) *MockAPIClient_NodeList_Call {
	_c.Call.Return(run)
	return _c
}

// NodeRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NodeRemove(ctx context.Context, nodeID string, options swarm.NodeRemoveOptions) error {
	ret := _mock.Called(ctx, nodeID, options)

	if len(ret) == 0 {
		panic("no return value specified for NodeRemove")
	}

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

// MockAPIClient_NodeRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeRemove'
type MockAPIClient_NodeRemove_Call struct {
	*mock.Call
}

// NodeRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeID string
//   - options swarm.NodeRemoveOptions
func (_e *MockAPIClient_Expecter) NodeRemove(ctx any, nodeID any, options any) *MockAPIClient_NodeRemove_Call {
	return &MockAPIClient_NodeRemove_Call{Call: _e.mock.On("NodeRemove", ctx, nodeID, options)}
}

func (_c *MockAPIClient_NodeRemove_Call) Run(run func(ctx context.Context, nodeID string, options swarm.NodeRemoveOptions)) *MockAPIClient_NodeRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.NodeRemoveOptions
		if args[2] != nil {
			arg2 = args[2].(swarm.NodeRemoveOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_NodeRemove_Call) Return(err error) *MockAPIClient_NodeRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_NodeRemove_Call) RunAndReturn(run func(ctx context.Context, nodeID string, options swarm.NodeRemoveOptions) error) *MockAPIClient_NodeRemove_Call {
	_c.Call.Return(run)
	return _c
}

// NodeUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) NodeUpdate(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error {
	ret := _mock.Called(ctx, nodeID, version, node)

	if len(ret) == 0 {
		panic("no return value specified for NodeUpdate")
	}

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

// MockAPIClient_NodeUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeUpdate'
type MockAPIClient_NodeUpdate_Call struct {
	*mock.Call
}

// NodeUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - nodeID string
//   - version swarm.Version
//   - node swarm.NodeSpec
func (_e *MockAPIClient_Expecter) NodeUpdate(ctx any, nodeID any, version any, node any) *MockAPIClient_NodeUpdate_Call {
	return &MockAPIClient_NodeUpdate_Call{Call: _e.mock.On("NodeUpdate", ctx, nodeID, version, node)}
}

func (_c *MockAPIClient_NodeUpdate_Call) Run(run func(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec)) *MockAPIClient_NodeUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.Version
		if args[2] != nil {
			arg2 = args[2].(swarm.Version)
		}
		var arg3 swarm.NodeSpec
		if args[3] != nil {
			arg3 = args[3].(swarm.NodeSpec)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_NodeUpdate_Call) Return(err error) *MockAPIClient_NodeUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_NodeUpdate_Call) RunAndReturn(run func(ctx context.Context, nodeID string, version swarm.Version, node swarm.NodeSpec) error) *MockAPIClient_NodeUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// Ping provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) Ping(ctx context.Context) (types.Ping, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Ping")
	}

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

// MockAPIClient_Ping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ping'
type MockAPIClient_Ping_Call struct {
	*mock.Call
}

// Ping is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) Ping(ctx any) *MockAPIClient_Ping_Call {
	return &MockAPIClient_Ping_Call{Call: _e.mock.On("Ping", ctx)}
}

func (_c *MockAPIClient_Ping_Call) Run(run func(ctx context.Context)) *MockAPIClient_Ping_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_Ping_Call) Return(ping types.Ping, err error) *MockAPIClient_Ping_Call {
	_c.Call.Return(ping, err)
	return _c
}

func (_c *MockAPIClient_Ping_Call) RunAndReturn(run func(ctx context.Context) (types.Ping, error)) *MockAPIClient_Ping_Call {
	_c.Call.Return(run)
	return _c
}

// PluginCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginCreate(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions) error {
	ret := _mock.Called(ctx, createContext, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginCreate")
	}

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

// MockAPIClient_PluginCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginCreate'
type MockAPIClient_PluginCreate_Call struct {
	*mock.Call
}

// PluginCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - createContext io.Reader
//   - options types.PluginCreateOptions
func (_e *MockAPIClient_Expecter) PluginCreate(ctx any, createContext any, options any) *MockAPIClient_PluginCreate_Call {
	return &MockAPIClient_PluginCreate_Call{Call: _e.mock.On("PluginCreate", ctx, createContext, options)}
}

func (_c *MockAPIClient_PluginCreate_Call) Run(run func(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions)) *MockAPIClient_PluginCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 types.PluginCreateOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginCreateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginCreate_Call) Return(err error) *MockAPIClient_PluginCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_PluginCreate_Call) RunAndReturn(run func(ctx context.Context, createContext io.Reader, options types.PluginCreateOptions) error) *MockAPIClient_PluginCreate_Call {
	_c.Call.Return(run)
	return _c
}

// PluginDisable provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginDisable(ctx context.Context, name string, options types.PluginDisableOptions) error {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginDisable")
	}

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

// MockAPIClient_PluginDisable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginDisable'
type MockAPIClient_PluginDisable_Call struct {
	*mock.Call
}

// PluginDisable is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options types.PluginDisableOptions
func (_e *MockAPIClient_Expecter) PluginDisable(ctx any, name any, options any) *MockAPIClient_PluginDisable_Call {
	return &MockAPIClient_PluginDisable_Call{Call: _e.mock.On("PluginDisable", ctx, name, options)}
}

func (_c *MockAPIClient_PluginDisable_Call) Run(run func(ctx context.Context, name string, options types.PluginDisableOptions)) *MockAPIClient_PluginDisable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 types.PluginDisableOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginDisableOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginDisable_Call) Return(err error) *MockAPIClient_PluginDisable_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_PluginDisable_Call) RunAndReturn(run func(ctx context.Context, name string, options types.PluginDisableOptions) error) *MockAPIClient_PluginDisable_Call {
	_c.Call.Return(run)
	return _c
}

// PluginEnable provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginEnable(ctx context.Context, name string, options types.PluginEnableOptions) error {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginEnable")
	}

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

// MockAPIClient_PluginEnable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginEnable'
type MockAPIClient_PluginEnable_Call struct {
	*mock.Call
}

// PluginEnable is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options types.PluginEnableOptions
func (_e *MockAPIClient_Expecter) PluginEnable(ctx any, name any, options any) *MockAPIClient_PluginEnable_Call {
	return &MockAPIClient_PluginEnable_Call{Call: _e.mock.On("PluginEnable", ctx, name, options)}
}

func (_c *MockAPIClient_PluginEnable_Call) Run(run func(ctx context.Context, name string, options types.PluginEnableOptions)) *MockAPIClient_PluginEnable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 types.PluginEnableOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginEnableOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginEnable_Call) Return(err error) *MockAPIClient_PluginEnable_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_PluginEnable_Call) RunAndReturn(run func(ctx context.Context, name string, options types.PluginEnableOptions) error) *MockAPIClient_PluginEnable_Call {
	_c.Call.Return(run)
	return _c
}

// PluginInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
	ret := _mock.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for PluginInspectWithRaw")
	}

	var r0 *types.Plugin
	var r1 []byte
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*types.Plugin, []byte, error)); ok {
		return returnFunc(ctx, name)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *types.Plugin); ok {
		r0 = returnFunc(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.Plugin)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) []byte); ok {
		r1 = returnFunc(ctx, name)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, string) error); ok {
		r2 = returnFunc(ctx, name)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockAPIClient_PluginInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginInspectWithRaw'
type MockAPIClient_PluginInspectWithRaw_Call struct {
	*mock.Call
}

// PluginInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockAPIClient_Expecter) PluginInspectWithRaw(ctx any, name any) *MockAPIClient_PluginInspectWithRaw_Call {
	return &MockAPIClient_PluginInspectWithRaw_Call{Call: _e.mock.On("PluginInspectWithRaw", ctx, name)}
}

func (_c *MockAPIClient_PluginInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_PluginInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginInspectWithRaw_Call) Return(plugin *types.Plugin, bytes []byte, err error) *MockAPIClient_PluginInspectWithRaw_Call {
	_c.Call.Return(plugin, bytes, err)
	return _c
}

func (_c *MockAPIClient_PluginInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (*types.Plugin, []byte, error)) *MockAPIClient_PluginInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// PluginInstall provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginInstall(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginInstall")
	}

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

// MockAPIClient_PluginInstall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginInstall'
type MockAPIClient_PluginInstall_Call struct {
	*mock.Call
}

// PluginInstall is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options types.PluginInstallOptions
func (_e *MockAPIClient_Expecter) PluginInstall(ctx any, name any, options any) *MockAPIClient_PluginInstall_Call {
	return &MockAPIClient_PluginInstall_Call{Call: _e.mock.On("PluginInstall", ctx, name, options)}
}

func (_c *MockAPIClient_PluginInstall_Call) Run(run func(ctx context.Context, name string, options types.PluginInstallOptions)) *MockAPIClient_PluginInstall_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 types.PluginInstallOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginInstallOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginInstall_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginInstall_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_PluginInstall_Call) RunAndReturn(run func(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error)) *MockAPIClient_PluginInstall_Call {
	_c.Call.Return(run)
	return _c
}

// PluginList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginList(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error) {
	ret := _mock.Called(ctx, filter)

	if len(ret) == 0 {
		panic("no return value specified for PluginList")
	}

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

// MockAPIClient_PluginList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginList'
type MockAPIClient_PluginList_Call struct {
	*mock.Call
}

// PluginList is a helper method to define mock.On call
//   - ctx context.Context
//   - filter filters.Args
func (_e *MockAPIClient_Expecter) PluginList(ctx any, filter any) *MockAPIClient_PluginList_Call {
	return &MockAPIClient_PluginList_Call{Call: _e.mock.On("PluginList", ctx, filter)}
}

func (_c *MockAPIClient_PluginList_Call) Run(run func(ctx context.Context, filter filters.Args)) *MockAPIClient_PluginList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 filters.Args
		if args[1] != nil {
			arg1 = args[1].(filters.Args)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginList_Call) Return(pluginsListResponse types.PluginsListResponse, err error) *MockAPIClient_PluginList_Call {
	_c.Call.Return(pluginsListResponse, err)
	return _c
}

func (_c *MockAPIClient_PluginList_Call) RunAndReturn(run func(ctx context.Context, filter filters.Args) (types.PluginsListResponse, error)) *MockAPIClient_PluginList_Call {
	_c.Call.Return(run)
	return _c
}

// PluginPush provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginPush(ctx context.Context, name string, registryAuth string) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, name, registryAuth)

	if len(ret) == 0 {
		panic("no return value specified for PluginPush")
	}

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

// MockAPIClient_PluginPush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginPush'
type MockAPIClient_PluginPush_Call struct {
	*mock.Call
}

// PluginPush is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - registryAuth string
func (_e *MockAPIClient_Expecter) PluginPush(ctx any, name any, registryAuth any) *MockAPIClient_PluginPush_Call {
	return &MockAPIClient_PluginPush_Call{Call: _e.mock.On("PluginPush", ctx, name, registryAuth)}
}

func (_c *MockAPIClient_PluginPush_Call) Run(run func(ctx context.Context, name string, registryAuth string)) *MockAPIClient_PluginPush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginPush_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginPush_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_PluginPush_Call) RunAndReturn(run func(ctx context.Context, name string, registryAuth string) (io.ReadCloser, error)) *MockAPIClient_PluginPush_Call {
	_c.Call.Return(run)
	return _c
}

// PluginRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginRemove(ctx context.Context, name string, options types.PluginRemoveOptions) error {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginRemove")
	}

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

// MockAPIClient_PluginRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginRemove'
type MockAPIClient_PluginRemove_Call struct {
	*mock.Call
}

// PluginRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options types.PluginRemoveOptions
func (_e *MockAPIClient_Expecter) PluginRemove(ctx any, name any, options any) *MockAPIClient_PluginRemove_Call {
	return &MockAPIClient_PluginRemove_Call{Call: _e.mock.On("PluginRemove", ctx, name, options)}
}

func (_c *MockAPIClient_PluginRemove_Call) Run(run func(ctx context.Context, name string, options types.PluginRemoveOptions)) *MockAPIClient_PluginRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 types.PluginRemoveOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginRemoveOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginRemove_Call) Return(err error) *MockAPIClient_PluginRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_PluginRemove_Call) RunAndReturn(run func(ctx context.Context, name string, options types.PluginRemoveOptions) error) *MockAPIClient_PluginRemove_Call {
	_c.Call.Return(run)
	return _c
}

// PluginSet provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginSet(ctx context.Context, name string, args []string) error {
	ret := _mock.Called(ctx, name, args)

	if len(ret) == 0 {
		panic("no return value specified for PluginSet")
	}

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

// MockAPIClient_PluginSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginSet'
type MockAPIClient_PluginSet_Call struct {
	*mock.Call
}

// PluginSet is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - args []string
func (_e *MockAPIClient_Expecter) PluginSet(ctx any, name any, args any) *MockAPIClient_PluginSet_Call {
	return &MockAPIClient_PluginSet_Call{Call: _e.mock.On("PluginSet", ctx, name, args)}
}

func (_c *MockAPIClient_PluginSet_Call) Run(run func(ctx context.Context, name string, args []string)) *MockAPIClient_PluginSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginSet_Call) Return(err error) *MockAPIClient_PluginSet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_PluginSet_Call) RunAndReturn(run func(ctx context.Context, name string, args []string) error) *MockAPIClient_PluginSet_Call {
	_c.Call.Return(run)
	return _c
}

// PluginUpgrade provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) PluginUpgrade(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, name, options)

	if len(ret) == 0 {
		panic("no return value specified for PluginUpgrade")
	}

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

// MockAPIClient_PluginUpgrade_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PluginUpgrade'
type MockAPIClient_PluginUpgrade_Call struct {
	*mock.Call
}

// PluginUpgrade is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - options types.PluginInstallOptions
func (_e *MockAPIClient_Expecter) PluginUpgrade(ctx any, name any, options any) *MockAPIClient_PluginUpgrade_Call {
	return &MockAPIClient_PluginUpgrade_Call{Call: _e.mock.On("PluginUpgrade", ctx, name, options)}
}

func (_c *MockAPIClient_PluginUpgrade_Call) Run(run func(ctx context.Context, name string, options types.PluginInstallOptions)) *MockAPIClient_PluginUpgrade_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 types.PluginInstallOptions
		if args[2] != nil {
			arg2 = args[2].(types.PluginInstallOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_PluginUpgrade_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_PluginUpgrade_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_PluginUpgrade_Call) RunAndReturn(run func(ctx context.Context, name string, options types.PluginInstallOptions) (io.ReadCloser, error)) *MockAPIClient_PluginUpgrade_Call {
	_c.Call.Return(run)
	return _c
}

// RegistryLogin provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) RegistryLogin(ctx context.Context, auth registry.AuthConfig) (registry.AuthenticateOKBody, error) {
	ret := _mock.Called(ctx, auth)

	if len(ret) == 0 {
		panic("no return value specified for RegistryLogin")
	}

	var r0 registry.AuthenticateOKBody
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, registry.AuthConfig) (registry.AuthenticateOKBody, error)); ok {
		return returnFunc(ctx, auth)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, registry.AuthConfig) registry.AuthenticateOKBody); ok {
		r0 = returnFunc(ctx, auth)
	} else {
		r0 = ret.Get(0).(registry.AuthenticateOKBody)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, registry.AuthConfig) error); ok {
		r1 = returnFunc(ctx, auth)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_RegistryLogin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegistryLogin'
type MockAPIClient_RegistryLogin_Call struct {
	*mock.Call
}

// RegistryLogin is a helper method to define mock.On call
//   - ctx context.Context
//   - auth registry.AuthConfig
func (_e *MockAPIClient_Expecter) RegistryLogin(ctx any, auth any) *MockAPIClient_RegistryLogin_Call {
	return &MockAPIClient_RegistryLogin_Call{Call: _e.mock.On("RegistryLogin", ctx, auth)}
}

func (_c *MockAPIClient_RegistryLogin_Call) Run(run func(ctx context.Context, auth registry.AuthConfig)) *MockAPIClient_RegistryLogin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 registry.AuthConfig
		if args[1] != nil {
			arg1 = args[1].(registry.AuthConfig)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_RegistryLogin_Call) Return(authenticateOKBody registry.AuthenticateOKBody, err error) *MockAPIClient_RegistryLogin_Call {
	_c.Call.Return(authenticateOKBody, err)
	return _c
}

func (_c *MockAPIClient_RegistryLogin_Call) RunAndReturn(run func(ctx context.Context, auth registry.AuthConfig) (registry.AuthenticateOKBody, error)) *MockAPIClient_RegistryLogin_Call {
	_c.Call.Return(run)
	return _c
}

// SecretCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SecretCreate(ctx context.Context, secret swarm.SecretSpec) (swarm.SecretCreateResponse, error) {
	ret := _mock.Called(ctx, secret)

	if len(ret) == 0 {
		panic("no return value specified for SecretCreate")
	}

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

// MockAPIClient_SecretCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretCreate'
type MockAPIClient_SecretCreate_Call struct {
	*mock.Call
}

// SecretCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - secret swarm.SecretSpec
func (_e *MockAPIClient_Expecter) SecretCreate(ctx any, secret any) *MockAPIClient_SecretCreate_Call {
	return &MockAPIClient_SecretCreate_Call{Call: _e.mock.On("SecretCreate", ctx, secret)}
}

func (_c *MockAPIClient_SecretCreate_Call) Run(run func(ctx context.Context, secret swarm.SecretSpec)) *MockAPIClient_SecretCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.SecretSpec
		if args[1] != nil {
			arg1 = args[1].(swarm.SecretSpec)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SecretCreate_Call) Return(secretCreateResponse swarm.SecretCreateResponse, err error) *MockAPIClient_SecretCreate_Call {
	_c.Call.Return(secretCreateResponse, err)
	return _c
}

func (_c *MockAPIClient_SecretCreate_Call) RunAndReturn(run func(ctx context.Context, secret swarm.SecretSpec) (swarm.SecretCreateResponse, error)) *MockAPIClient_SecretCreate_Call {
	_c.Call.Return(run)
	return _c
}

// SecretInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SecretInspectWithRaw(ctx context.Context, name string) (swarm.Secret, []byte, error) {
	ret := _mock.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for SecretInspectWithRaw")
	}

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

// MockAPIClient_SecretInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretInspectWithRaw'
type MockAPIClient_SecretInspectWithRaw_Call struct {
	*mock.Call
}

// SecretInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockAPIClient_Expecter) SecretInspectWithRaw(ctx any, name any) *MockAPIClient_SecretInspectWithRaw_Call {
	return &MockAPIClient_SecretInspectWithRaw_Call{Call: _e.mock.On("SecretInspectWithRaw", ctx, name)}
}

func (_c *MockAPIClient_SecretInspectWithRaw_Call) Run(run func(ctx context.Context, name string)) *MockAPIClient_SecretInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SecretInspectWithRaw_Call) Return(secret swarm.Secret, bytes []byte, err error) *MockAPIClient_SecretInspectWithRaw_Call {
	_c.Call.Return(secret, bytes, err)
	return _c
}

func (_c *MockAPIClient_SecretInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, name string) (swarm.Secret, []byte, error)) *MockAPIClient_SecretInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// SecretList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SecretList(ctx context.Context, options swarm.SecretListOptions) ([]swarm.Secret, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for SecretList")
	}

	var r0 []swarm.Secret
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.SecretListOptions) ([]swarm.Secret, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.SecretListOptions) []swarm.Secret); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Secret)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, swarm.SecretListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_SecretList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretList'
type MockAPIClient_SecretList_Call struct {
	*mock.Call
}

// SecretList is a helper method to define mock.On call
//   - ctx context.Context
//   - options swarm.SecretListOptions
func (_e *MockAPIClient_Expecter) SecretList(ctx any, options any) *MockAPIClient_SecretList_Call {
	return &MockAPIClient_SecretList_Call{Call: _e.mock.On("SecretList", ctx, options)}
}

func (_c *MockAPIClient_SecretList_Call) Run(run func(ctx context.Context, options swarm.SecretListOptions)) *MockAPIClient_SecretList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.SecretListOptions
		if args[1] != nil {
			arg1 = args[1].(swarm.SecretListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SecretList_Call) Return(secrets []swarm.Secret, err error) *MockAPIClient_SecretList_Call {
	_c.Call.Return(secrets, err)
	return _c
}

func (_c *MockAPIClient_SecretList_Call) RunAndReturn(run func(ctx context.Context, options swarm.SecretListOptions) ([]swarm.Secret, error)) *MockAPIClient_SecretList_Call {
	_c.Call.Return(run)
	return _c
}

// SecretRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SecretRemove(ctx context.Context, id string) error {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for SecretRemove")
	}

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

// MockAPIClient_SecretRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretRemove'
type MockAPIClient_SecretRemove_Call struct {
	*mock.Call
}

// SecretRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockAPIClient_Expecter) SecretRemove(ctx any, id any) *MockAPIClient_SecretRemove_Call {
	return &MockAPIClient_SecretRemove_Call{Call: _e.mock.On("SecretRemove", ctx, id)}
}

func (_c *MockAPIClient_SecretRemove_Call) Run(run func(ctx context.Context, id string)) *MockAPIClient_SecretRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SecretRemove_Call) Return(err error) *MockAPIClient_SecretRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SecretRemove_Call) RunAndReturn(run func(ctx context.Context, id string) error) *MockAPIClient_SecretRemove_Call {
	_c.Call.Return(run)
	return _c
}

// SecretUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SecretUpdate(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error {
	ret := _mock.Called(ctx, id, version, secret)

	if len(ret) == 0 {
		panic("no return value specified for SecretUpdate")
	}

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

// MockAPIClient_SecretUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SecretUpdate'
type MockAPIClient_SecretUpdate_Call struct {
	*mock.Call
}

// SecretUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - version swarm.Version
//   - secret swarm.SecretSpec
func (_e *MockAPIClient_Expecter) SecretUpdate(ctx any, id any, version any, secret any) *MockAPIClient_SecretUpdate_Call {
	return &MockAPIClient_SecretUpdate_Call{Call: _e.mock.On("SecretUpdate", ctx, id, version, secret)}
}

func (_c *MockAPIClient_SecretUpdate_Call) Run(run func(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec)) *MockAPIClient_SecretUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.Version
		if args[2] != nil {
			arg2 = args[2].(swarm.Version)
		}
		var arg3 swarm.SecretSpec
		if args[3] != nil {
			arg3 = args[3].(swarm.SecretSpec)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_SecretUpdate_Call) Return(err error) *MockAPIClient_SecretUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SecretUpdate_Call) RunAndReturn(run func(ctx context.Context, id string, version swarm.Version, secret swarm.SecretSpec) error) *MockAPIClient_SecretUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServerVersion provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServerVersion(ctx context.Context) (types.Version, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ServerVersion")
	}

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

// MockAPIClient_ServerVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServerVersion'
type MockAPIClient_ServerVersion_Call struct {
	*mock.Call
}

// ServerVersion is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) ServerVersion(ctx any) *MockAPIClient_ServerVersion_Call {
	return &MockAPIClient_ServerVersion_Call{Call: _e.mock.On("ServerVersion", ctx)}
}

func (_c *MockAPIClient_ServerVersion_Call) Run(run func(ctx context.Context)) *MockAPIClient_ServerVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServerVersion_Call) Return(version types.Version, err error) *MockAPIClient_ServerVersion_Call {
	_c.Call.Return(version, err)
	return _c
}

func (_c *MockAPIClient_ServerVersion_Call) RunAndReturn(run func(ctx context.Context) (types.Version, error)) *MockAPIClient_ServerVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceCreate(ctx context.Context, service swarm.ServiceSpec, options swarm.ServiceCreateOptions) (swarm.ServiceCreateResponse, error) {
	ret := _mock.Called(ctx, service, options)

	if len(ret) == 0 {
		panic("no return value specified for ServiceCreate")
	}

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

// MockAPIClient_ServiceCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceCreate'
type MockAPIClient_ServiceCreate_Call struct {
	*mock.Call
}

// ServiceCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - service swarm.ServiceSpec
//   - options swarm.ServiceCreateOptions
func (_e *MockAPIClient_Expecter) ServiceCreate(ctx any, service any, options any) *MockAPIClient_ServiceCreate_Call {
	return &MockAPIClient_ServiceCreate_Call{Call: _e.mock.On("ServiceCreate", ctx, service, options)}
}

func (_c *MockAPIClient_ServiceCreate_Call) Run(run func(ctx context.Context, service swarm.ServiceSpec, options swarm.ServiceCreateOptions)) *MockAPIClient_ServiceCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.ServiceSpec
		if args[1] != nil {
			arg1 = args[1].(swarm.ServiceSpec)
		}
		var arg2 swarm.ServiceCreateOptions
		if args[2] != nil {
			arg2 = args[2].(swarm.ServiceCreateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceCreate_Call) Return(serviceCreateResponse swarm.ServiceCreateResponse, err error) *MockAPIClient_ServiceCreate_Call {
	_c.Call.Return(serviceCreateResponse, err)
	return _c
}

func (_c *MockAPIClient_ServiceCreate_Call) RunAndReturn(run func(ctx context.Context, service swarm.ServiceSpec, options swarm.ServiceCreateOptions) (swarm.ServiceCreateResponse, error)) *MockAPIClient_ServiceCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceInspectWithRaw(ctx context.Context, serviceID string, options swarm.ServiceInspectOptions) (swarm.Service, []byte, error) {
	ret := _mock.Called(ctx, serviceID, options)

	if len(ret) == 0 {
		panic("no return value specified for ServiceInspectWithRaw")
	}

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

// MockAPIClient_ServiceInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceInspectWithRaw'
type MockAPIClient_ServiceInspectWithRaw_Call struct {
	*mock.Call
}

// ServiceInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceID string
//   - options swarm.ServiceInspectOptions
func (_e *MockAPIClient_Expecter) ServiceInspectWithRaw(ctx any, serviceID any, options any) *MockAPIClient_ServiceInspectWithRaw_Call {
	return &MockAPIClient_ServiceInspectWithRaw_Call{Call: _e.mock.On("ServiceInspectWithRaw", ctx, serviceID, options)}
}

func (_c *MockAPIClient_ServiceInspectWithRaw_Call) Run(run func(ctx context.Context, serviceID string, options swarm.ServiceInspectOptions)) *MockAPIClient_ServiceInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.ServiceInspectOptions
		if args[2] != nil {
			arg2 = args[2].(swarm.ServiceInspectOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceInspectWithRaw_Call) Return(service swarm.Service, bytes []byte, err error) *MockAPIClient_ServiceInspectWithRaw_Call {
	_c.Call.Return(service, bytes, err)
	return _c
}

func (_c *MockAPIClient_ServiceInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, serviceID string, options swarm.ServiceInspectOptions) (swarm.Service, []byte, error)) *MockAPIClient_ServiceInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceList(ctx context.Context, options swarm.ServiceListOptions) ([]swarm.Service, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for ServiceList")
	}

	var r0 []swarm.Service
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.ServiceListOptions) ([]swarm.Service, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.ServiceListOptions) []swarm.Service); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Service)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, swarm.ServiceListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceList'
type MockAPIClient_ServiceList_Call struct {
	*mock.Call
}

// ServiceList is a helper method to define mock.On call
//   - ctx context.Context
//   - options swarm.ServiceListOptions
func (_e *MockAPIClient_Expecter) ServiceList(ctx any, options any) *MockAPIClient_ServiceList_Call {
	return &MockAPIClient_ServiceList_Call{Call: _e.mock.On("ServiceList", ctx, options)}
}

func (_c *MockAPIClient_ServiceList_Call) Run(run func(ctx context.Context, options swarm.ServiceListOptions)) *MockAPIClient_ServiceList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.ServiceListOptions
		if args[1] != nil {
			arg1 = args[1].(swarm.ServiceListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceList_Call) Return(services []swarm.Service, err error) *MockAPIClient_ServiceList_Call {
	_c.Call.Return(services, err)
	return _c
}

func (_c *MockAPIClient_ServiceList_Call) RunAndReturn(run func(ctx context.Context, options swarm.ServiceListOptions) ([]swarm.Service, error)) *MockAPIClient_ServiceList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceLogs provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceLogs(ctx context.Context, serviceID string, options container.LogsOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, serviceID, options)

	if len(ret) == 0 {
		panic("no return value specified for ServiceLogs")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, serviceID, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, serviceID, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.LogsOptions) error); ok {
		r1 = returnFunc(ctx, serviceID, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_ServiceLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceLogs'
type MockAPIClient_ServiceLogs_Call struct {
	*mock.Call
}

// ServiceLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceID string
//   - options container.LogsOptions
func (_e *MockAPIClient_Expecter) ServiceLogs(ctx any, serviceID any, options any) *MockAPIClient_ServiceLogs_Call {
	return &MockAPIClient_ServiceLogs_Call{Call: _e.mock.On("ServiceLogs", ctx, serviceID, options)}
}

func (_c *MockAPIClient_ServiceLogs_Call) Run(run func(ctx context.Context, serviceID string, options container.LogsOptions)) *MockAPIClient_ServiceLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.LogsOptions
		if args[2] != nil {
			arg2 = args[2].(container.LogsOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_ServiceLogs_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_ServiceLogs_Call) RunAndReturn(run func(ctx context.Context, serviceID string, options container.LogsOptions) (io.ReadCloser, error)) *MockAPIClient_ServiceLogs_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceRemove(ctx context.Context, serviceID string) error {
	ret := _mock.Called(ctx, serviceID)

	if len(ret) == 0 {
		panic("no return value specified for ServiceRemove")
	}

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

// MockAPIClient_ServiceRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceRemove'
type MockAPIClient_ServiceRemove_Call struct {
	*mock.Call
}

// ServiceRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceID string
func (_e *MockAPIClient_Expecter) ServiceRemove(ctx any, serviceID any) *MockAPIClient_ServiceRemove_Call {
	return &MockAPIClient_ServiceRemove_Call{Call: _e.mock.On("ServiceRemove", ctx, serviceID)}
}

func (_c *MockAPIClient_ServiceRemove_Call) Run(run func(ctx context.Context, serviceID string)) *MockAPIClient_ServiceRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceRemove_Call) Return(err error) *MockAPIClient_ServiceRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_ServiceRemove_Call) RunAndReturn(run func(ctx context.Context, serviceID string) error) *MockAPIClient_ServiceRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options swarm.ServiceUpdateOptions) (swarm.ServiceUpdateResponse, error) {
	ret := _mock.Called(ctx, serviceID, version, service, options)

	if len(ret) == 0 {
		panic("no return value specified for ServiceUpdate")
	}

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

// MockAPIClient_ServiceUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceUpdate'
type MockAPIClient_ServiceUpdate_Call struct {
	*mock.Call
}

// ServiceUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - serviceID string
//   - version swarm.Version
//   - service swarm.ServiceSpec
//   - options swarm.ServiceUpdateOptions
func (_e *MockAPIClient_Expecter) ServiceUpdate(ctx any, serviceID any, version any, service any, options any) *MockAPIClient_ServiceUpdate_Call {
	return &MockAPIClient_ServiceUpdate_Call{Call: _e.mock.On("ServiceUpdate", ctx, serviceID, version, service, options)}
}

func (_c *MockAPIClient_ServiceUpdate_Call) Run(run func(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options swarm.ServiceUpdateOptions)) *MockAPIClient_ServiceUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.Version
		if args[2] != nil {
			arg2 = args[2].(swarm.Version)
		}
		var arg3 swarm.ServiceSpec
		if args[3] != nil {
			arg3 = args[3].(swarm.ServiceSpec)
		}
		var arg4 swarm.ServiceUpdateOptions
		if args[4] != nil {
			arg4 = args[4].(swarm.ServiceUpdateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockAPIClient_ServiceUpdate_Call) Return(serviceUpdateResponse swarm.ServiceUpdateResponse, err error) *MockAPIClient_ServiceUpdate_Call {
	_c.Call.Return(serviceUpdateResponse, err)
	return _c
}

func (_c *MockAPIClient_ServiceUpdate_Call) RunAndReturn(run func(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options swarm.ServiceUpdateOptions) (swarm.ServiceUpdateResponse, error)) *MockAPIClient_ServiceUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmGetUnlockKey provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmGetUnlockKey(ctx context.Context) (swarm.UnlockKeyResponse, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for SwarmGetUnlockKey")
	}

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

// MockAPIClient_SwarmGetUnlockKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmGetUnlockKey'
type MockAPIClient_SwarmGetUnlockKey_Call struct {
	*mock.Call
}

// SwarmGetUnlockKey is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) SwarmGetUnlockKey(ctx any) *MockAPIClient_SwarmGetUnlockKey_Call {
	return &MockAPIClient_SwarmGetUnlockKey_Call{Call: _e.mock.On("SwarmGetUnlockKey", ctx)}
}

func (_c *MockAPIClient_SwarmGetUnlockKey_Call) Run(run func(ctx context.Context)) *MockAPIClient_SwarmGetUnlockKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmGetUnlockKey_Call) Return(unlockKeyResponse swarm.UnlockKeyResponse, err error) *MockAPIClient_SwarmGetUnlockKey_Call {
	_c.Call.Return(unlockKeyResponse, err)
	return _c
}

func (_c *MockAPIClient_SwarmGetUnlockKey_Call) RunAndReturn(run func(ctx context.Context) (swarm.UnlockKeyResponse, error)) *MockAPIClient_SwarmGetUnlockKey_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmInit provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmInit(ctx context.Context, req swarm.InitRequest) (string, error) {
	ret := _mock.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for SwarmInit")
	}

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

// MockAPIClient_SwarmInit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmInit'
type MockAPIClient_SwarmInit_Call struct {
	*mock.Call
}

// SwarmInit is a helper method to define mock.On call
//   - ctx context.Context
//   - req swarm.InitRequest
func (_e *MockAPIClient_Expecter) SwarmInit(ctx any, req any) *MockAPIClient_SwarmInit_Call {
	return &MockAPIClient_SwarmInit_Call{Call: _e.mock.On("SwarmInit", ctx, req)}
}

func (_c *MockAPIClient_SwarmInit_Call) Run(run func(ctx context.Context, req swarm.InitRequest)) *MockAPIClient_SwarmInit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.InitRequest
		if args[1] != nil {
			arg1 = args[1].(swarm.InitRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmInit_Call) Return(s string, err error) *MockAPIClient_SwarmInit_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockAPIClient_SwarmInit_Call) RunAndReturn(run func(ctx context.Context, req swarm.InitRequest) (string, error)) *MockAPIClient_SwarmInit_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmInspect(ctx context.Context) (swarm.Swarm, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for SwarmInspect")
	}

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

// MockAPIClient_SwarmInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmInspect'
type MockAPIClient_SwarmInspect_Call struct {
	*mock.Call
}

// SwarmInspect is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockAPIClient_Expecter) SwarmInspect(ctx any) *MockAPIClient_SwarmInspect_Call {
	return &MockAPIClient_SwarmInspect_Call{Call: _e.mock.On("SwarmInspect", ctx)}
}

func (_c *MockAPIClient_SwarmInspect_Call) Run(run func(ctx context.Context)) *MockAPIClient_SwarmInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmInspect_Call) Return(swarm1 swarm.Swarm, err error) *MockAPIClient_SwarmInspect_Call {
	_c.Call.Return(swarm1, err)
	return _c
}

func (_c *MockAPIClient_SwarmInspect_Call) RunAndReturn(run func(ctx context.Context) (swarm.Swarm, error)) *MockAPIClient_SwarmInspect_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmJoin provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmJoin(ctx context.Context, req swarm.JoinRequest) error {
	ret := _mock.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for SwarmJoin")
	}

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

// MockAPIClient_SwarmJoin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmJoin'
type MockAPIClient_SwarmJoin_Call struct {
	*mock.Call
}

// SwarmJoin is a helper method to define mock.On call
//   - ctx context.Context
//   - req swarm.JoinRequest
func (_e *MockAPIClient_Expecter) SwarmJoin(ctx any, req any) *MockAPIClient_SwarmJoin_Call {
	return &MockAPIClient_SwarmJoin_Call{Call: _e.mock.On("SwarmJoin", ctx, req)}
}

func (_c *MockAPIClient_SwarmJoin_Call) Run(run func(ctx context.Context, req swarm.JoinRequest)) *MockAPIClient_SwarmJoin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.JoinRequest
		if args[1] != nil {
			arg1 = args[1].(swarm.JoinRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmJoin_Call) Return(err error) *MockAPIClient_SwarmJoin_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SwarmJoin_Call) RunAndReturn(run func(ctx context.Context, req swarm.JoinRequest) error) *MockAPIClient_SwarmJoin_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmLeave provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmLeave(ctx context.Context, force bool) error {
	ret := _mock.Called(ctx, force)

	if len(ret) == 0 {
		panic("no return value specified for SwarmLeave")
	}

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

// MockAPIClient_SwarmLeave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmLeave'
type MockAPIClient_SwarmLeave_Call struct {
	*mock.Call
}

// SwarmLeave is a helper method to define mock.On call
//   - ctx context.Context
//   - force bool
func (_e *MockAPIClient_Expecter) SwarmLeave(ctx any, force any) *MockAPIClient_SwarmLeave_Call {
	return &MockAPIClient_SwarmLeave_Call{Call: _e.mock.On("SwarmLeave", ctx, force)}
}

func (_c *MockAPIClient_SwarmLeave_Call) Run(run func(ctx context.Context, force bool)) *MockAPIClient_SwarmLeave_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmLeave_Call) Return(err error) *MockAPIClient_SwarmLeave_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SwarmLeave_Call) RunAndReturn(run func(ctx context.Context, force bool) error) *MockAPIClient_SwarmLeave_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmUnlock provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmUnlock(ctx context.Context, req swarm.UnlockRequest) error {
	ret := _mock.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for SwarmUnlock")
	}

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

// MockAPIClient_SwarmUnlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmUnlock'
type MockAPIClient_SwarmUnlock_Call struct {
	*mock.Call
}

// SwarmUnlock is a helper method to define mock.On call
//   - ctx context.Context
//   - req swarm.UnlockRequest
func (_e *MockAPIClient_Expecter) SwarmUnlock(ctx any, req any) *MockAPIClient_SwarmUnlock_Call {
	return &MockAPIClient_SwarmUnlock_Call{Call: _e.mock.On("SwarmUnlock", ctx, req)}
}

func (_c *MockAPIClient_SwarmUnlock_Call) Run(run func(ctx context.Context, req swarm.UnlockRequest)) *MockAPIClient_SwarmUnlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.UnlockRequest
		if args[1] != nil {
			arg1 = args[1].(swarm.UnlockRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmUnlock_Call) Return(err error) *MockAPIClient_SwarmUnlock_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SwarmUnlock_Call) RunAndReturn(run func(ctx context.Context, req swarm.UnlockRequest) error) *MockAPIClient_SwarmUnlock_Call {
	_c.Call.Return(run)
	return _c
}

// SwarmUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) SwarmUpdate(ctx context.Context, version swarm.Version, swarm1 swarm.Spec, flags swarm.UpdateFlags) error {
	ret := _mock.Called(ctx, version, swarm1, flags)

	if len(ret) == 0 {
		panic("no return value specified for SwarmUpdate")
	}

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

// MockAPIClient_SwarmUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwarmUpdate'
type MockAPIClient_SwarmUpdate_Call struct {
	*mock.Call
}

// SwarmUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - version swarm.Version
//   - swarm1 swarm.Spec
//   - flags swarm.UpdateFlags
func (_e *MockAPIClient_Expecter) SwarmUpdate(ctx any, version any, swarm1 any, flags any) *MockAPIClient_SwarmUpdate_Call {
	return &MockAPIClient_SwarmUpdate_Call{Call: _e.mock.On("SwarmUpdate", ctx, version, swarm1, flags)}
}

func (_c *MockAPIClient_SwarmUpdate_Call) Run(run func(ctx context.Context, version swarm.Version, swarm1 swarm.Spec, flags swarm.UpdateFlags)) *MockAPIClient_SwarmUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.Version
		if args[1] != nil {
			arg1 = args[1].(swarm.Version)
		}
		var arg2 swarm.Spec
		if args[2] != nil {
			arg2 = args[2].(swarm.Spec)
		}
		var arg3 swarm.UpdateFlags
		if args[3] != nil {
			arg3 = args[3].(swarm.UpdateFlags)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_SwarmUpdate_Call) Return(err error) *MockAPIClient_SwarmUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_SwarmUpdate_Call) RunAndReturn(run func(ctx context.Context, version swarm.Version, swarm1 swarm.Spec, flags swarm.UpdateFlags) error) *MockAPIClient_SwarmUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// TaskInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
	ret := _mock.Called(ctx, taskID)

	if len(ret) == 0 {
		panic("no return value specified for TaskInspectWithRaw")
	}

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

// MockAPIClient_TaskInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskInspectWithRaw'
type MockAPIClient_TaskInspectWithRaw_Call struct {
	*mock.Call
}

// TaskInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID string
func (_e *MockAPIClient_Expecter) TaskInspectWithRaw(ctx any, taskID any) *MockAPIClient_TaskInspectWithRaw_Call {
	return &MockAPIClient_TaskInspectWithRaw_Call{Call: _e.mock.On("TaskInspectWithRaw", ctx, taskID)}
}

func (_c *MockAPIClient_TaskInspectWithRaw_Call) Run(run func(ctx context.Context, taskID string)) *MockAPIClient_TaskInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_TaskInspectWithRaw_Call) Return(task swarm.Task, bytes []byte, err error) *MockAPIClient_TaskInspectWithRaw_Call {
	_c.Call.Return(task, bytes, err)
	return _c
}

func (_c *MockAPIClient_TaskInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, taskID string) (swarm.Task, []byte, error)) *MockAPIClient_TaskInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// TaskList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) TaskList(ctx context.Context, options swarm.TaskListOptions) ([]swarm.Task, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for TaskList")
	}

	var r0 []swarm.Task
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.TaskListOptions) ([]swarm.Task, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, swarm.TaskListOptions) []swarm.Task); ok {
		r0 = returnFunc(ctx, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]swarm.Task)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, swarm.TaskListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_TaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskList'
type MockAPIClient_TaskList_Call struct {
	*mock.Call
}

// TaskList is a helper method to define mock.On call
//   - ctx context.Context
//   - options swarm.TaskListOptions
func (_e *MockAPIClient_Expecter) TaskList(ctx any, options any) *MockAPIClient_TaskList_Call {
	return &MockAPIClient_TaskList_Call{Call: _e.mock.On("TaskList", ctx, options)}
}

func (_c *MockAPIClient_TaskList_Call) Run(run func(ctx context.Context, options swarm.TaskListOptions)) *MockAPIClient_TaskList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 swarm.TaskListOptions
		if args[1] != nil {
			arg1 = args[1].(swarm.TaskListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_TaskList_Call) Return(tasks []swarm.Task, err error) *MockAPIClient_TaskList_Call {
	_c.Call.Return(tasks, err)
	return _c
}

func (_c *MockAPIClient_TaskList_Call) RunAndReturn(run func(ctx context.Context, options swarm.TaskListOptions) ([]swarm.Task, error)) *MockAPIClient_TaskList_Call {
	_c.Call.Return(run)
	return _c
}

// TaskLogs provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) TaskLogs(ctx context.Context, taskID string, options container.LogsOptions) (io.ReadCloser, error) {
	ret := _mock.Called(ctx, taskID, options)

	if len(ret) == 0 {
		panic("no return value specified for TaskLogs")
	}

	var r0 io.ReadCloser
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) (io.ReadCloser, error)); ok {
		return returnFunc(ctx, taskID, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, container.LogsOptions) io.ReadCloser); ok {
		r0 = returnFunc(ctx, taskID, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, container.LogsOptions) error); ok {
		r1 = returnFunc(ctx, taskID, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_TaskLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TaskLogs'
type MockAPIClient_TaskLogs_Call struct {
	*mock.Call
}

// TaskLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - taskID string
//   - options container.LogsOptions
func (_e *MockAPIClient_Expecter) TaskLogs(ctx any, taskID any, options any) *MockAPIClient_TaskLogs_Call {
	return &MockAPIClient_TaskLogs_Call{Call: _e.mock.On("TaskLogs", ctx, taskID, options)}
}

func (_c *MockAPIClient_TaskLogs_Call) Run(run func(ctx context.Context, taskID string, options container.LogsOptions)) *MockAPIClient_TaskLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 container.LogsOptions
		if args[2] != nil {
			arg2 = args[2].(container.LogsOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_TaskLogs_Call) Return(readCloser io.ReadCloser, err error) *MockAPIClient_TaskLogs_Call {
	_c.Call.Return(readCloser, err)
	return _c
}

func (_c *MockAPIClient_TaskLogs_Call) RunAndReturn(run func(ctx context.Context, taskID string, options container.LogsOptions) (io.ReadCloser, error)) *MockAPIClient_TaskLogs_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeCreate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeCreate(ctx context.Context, options volume.CreateOptions) (volume.Volume, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for VolumeCreate")
	}

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

// MockAPIClient_VolumeCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeCreate'
type MockAPIClient_VolumeCreate_Call struct {
	*mock.Call
}

// VolumeCreate is a helper method to define mock.On call
//   - ctx context.Context
//   - options volume.CreateOptions
func (_e *MockAPIClient_Expecter) VolumeCreate(ctx any, options any) *MockAPIClient_VolumeCreate_Call {
	return &MockAPIClient_VolumeCreate_Call{Call: _e.mock.On("VolumeCreate", ctx, options)}
}

func (_c *MockAPIClient_VolumeCreate_Call) Run(run func(ctx context.Context, options volume.CreateOptions)) *MockAPIClient_VolumeCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 volume.CreateOptions
		if args[1] != nil {
			arg1 = args[1].(volume.CreateOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeCreate_Call) Return(volume1 volume.Volume, err error) *MockAPIClient_VolumeCreate_Call {
	_c.Call.Return(volume1, err)
	return _c
}

func (_c *MockAPIClient_VolumeCreate_Call) RunAndReturn(run func(ctx context.Context, options volume.CreateOptions) (volume.Volume, error)) *MockAPIClient_VolumeCreate_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeInspect provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeInspect(ctx context.Context, volumeID string) (volume.Volume, error) {
	ret := _mock.Called(ctx, volumeID)

	if len(ret) == 0 {
		panic("no return value specified for VolumeInspect")
	}

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

// MockAPIClient_VolumeInspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeInspect'
type MockAPIClient_VolumeInspect_Call struct {
	*mock.Call
}

// VolumeInspect is a helper method to define mock.On call
//   - ctx context.Context
//   - volumeID string
func (_e *MockAPIClient_Expecter) VolumeInspect(ctx any, volumeID any) *MockAPIClient_VolumeInspect_Call {
	return &MockAPIClient_VolumeInspect_Call{Call: _e.mock.On("VolumeInspect", ctx, volumeID)}
}

func (_c *MockAPIClient_VolumeInspect_Call) Run(run func(ctx context.Context, volumeID string)) *MockAPIClient_VolumeInspect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeInspect_Call) Return(volume1 volume.Volume, err error) *MockAPIClient_VolumeInspect_Call {
	_c.Call.Return(volume1, err)
	return _c
}

func (_c *MockAPIClient_VolumeInspect_Call) RunAndReturn(run func(ctx context.Context, volumeID string) (volume.Volume, error)) *MockAPIClient_VolumeInspect_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeInspectWithRaw provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeInspectWithRaw(ctx context.Context, volumeID string) (volume.Volume, []byte, error) {
	ret := _mock.Called(ctx, volumeID)

	if len(ret) == 0 {
		panic("no return value specified for VolumeInspectWithRaw")
	}

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

// MockAPIClient_VolumeInspectWithRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeInspectWithRaw'
type MockAPIClient_VolumeInspectWithRaw_Call struct {
	*mock.Call
}

// VolumeInspectWithRaw is a helper method to define mock.On call
//   - ctx context.Context
//   - volumeID string
func (_e *MockAPIClient_Expecter) VolumeInspectWithRaw(ctx any, volumeID any) *MockAPIClient_VolumeInspectWithRaw_Call {
	return &MockAPIClient_VolumeInspectWithRaw_Call{Call: _e.mock.On("VolumeInspectWithRaw", ctx, volumeID)}
}

func (_c *MockAPIClient_VolumeInspectWithRaw_Call) Run(run func(ctx context.Context, volumeID string)) *MockAPIClient_VolumeInspectWithRaw_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeInspectWithRaw_Call) Return(volume1 volume.Volume, bytes []byte, err error) *MockAPIClient_VolumeInspectWithRaw_Call {
	_c.Call.Return(volume1, bytes, err)
	return _c
}

func (_c *MockAPIClient_VolumeInspectWithRaw_Call) RunAndReturn(run func(ctx context.Context, volumeID string) (volume.Volume, []byte, error)) *MockAPIClient_VolumeInspectWithRaw_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeList provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeList(ctx context.Context, options volume.ListOptions) (volume.ListResponse, error) {
	ret := _mock.Called(ctx, options)

	if len(ret) == 0 {
		panic("no return value specified for VolumeList")
	}

	var r0 volume.ListResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, volume.ListOptions) (volume.ListResponse, error)); ok {
		return returnFunc(ctx, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, volume.ListOptions) volume.ListResponse); ok {
		r0 = returnFunc(ctx, options)
	} else {
		r0 = ret.Get(0).(volume.ListResponse)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, volume.ListOptions) error); ok {
		r1 = returnFunc(ctx, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_VolumeList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeList'
type MockAPIClient_VolumeList_Call struct {
	*mock.Call
}

// VolumeList is a helper method to define mock.On call
//   - ctx context.Context
//   - options volume.ListOptions
func (_e *MockAPIClient_Expecter) VolumeList(ctx any, options any) *MockAPIClient_VolumeList_Call {
	return &MockAPIClient_VolumeList_Call{Call: _e.mock.On("VolumeList", ctx, options)}
}

func (_c *MockAPIClient_VolumeList_Call) Run(run func(ctx context.Context, options volume.ListOptions)) *MockAPIClient_VolumeList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 volume.ListOptions
		if args[1] != nil {
			arg1 = args[1].(volume.ListOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeList_Call) Return(listResponse volume.ListResponse, err error) *MockAPIClient_VolumeList_Call {
	_c.Call.Return(listResponse, err)
	return _c
}

func (_c *MockAPIClient_VolumeList_Call) RunAndReturn(run func(ctx context.Context, options volume.ListOptions) (volume.ListResponse, error)) *MockAPIClient_VolumeList_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeRemove provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeRemove(ctx context.Context, volumeID string, force bool) error {
	ret := _mock.Called(ctx, volumeID, force)

	if len(ret) == 0 {
		panic("no return value specified for VolumeRemove")
	}

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

// MockAPIClient_VolumeRemove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeRemove'
type MockAPIClient_VolumeRemove_Call struct {
	*mock.Call
}

// VolumeRemove is a helper method to define mock.On call
//   - ctx context.Context
//   - volumeID string
//   - force bool
func (_e *MockAPIClient_Expecter) VolumeRemove(ctx any, volumeID any, force any) *MockAPIClient_VolumeRemove_Call {
	return &MockAPIClient_VolumeRemove_Call{Call: _e.mock.On("VolumeRemove", ctx, volumeID, force)}
}

func (_c *MockAPIClient_VolumeRemove_Call) Run(run func(ctx context.Context, volumeID string, force bool)) *MockAPIClient_VolumeRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeRemove_Call) Return(err error) *MockAPIClient_VolumeRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_VolumeRemove_Call) RunAndReturn(run func(ctx context.Context, volumeID string, force bool) error) *MockAPIClient_VolumeRemove_Call {
	_c.Call.Return(run)
	return _c
}

// VolumeUpdate provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumeUpdate(ctx context.Context, volumeID string, version swarm.Version, options volume.UpdateOptions) error {
	ret := _mock.Called(ctx, volumeID, version, options)

	if len(ret) == 0 {
		panic("no return value specified for VolumeUpdate")
	}

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

// MockAPIClient_VolumeUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumeUpdate'
type MockAPIClient_VolumeUpdate_Call struct {
	*mock.Call
}

// VolumeUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - volumeID string
//   - version swarm.Version
//   - options volume.UpdateOptions
func (_e *MockAPIClient_Expecter) VolumeUpdate(ctx any, volumeID any, version any, options any) *MockAPIClient_VolumeUpdate_Call {
	return &MockAPIClient_VolumeUpdate_Call{Call: _e.mock.On("VolumeUpdate", ctx, volumeID, version, options)}
}

func (_c *MockAPIClient_VolumeUpdate_Call) Run(run func(ctx context.Context, volumeID string, version swarm.Version, options volume.UpdateOptions)) *MockAPIClient_VolumeUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 swarm.Version
		if args[2] != nil {
			arg2 = args[2].(swarm.Version)
		}
		var arg3 volume.UpdateOptions
		if args[3] != nil {
			arg3 = args[3].(volume.UpdateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumeUpdate_Call) Return(err error) *MockAPIClient_VolumeUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockAPIClient_VolumeUpdate_Call) RunAndReturn(run func(ctx context.Context, volumeID string, version swarm.Version, options volume.UpdateOptions) error) *MockAPIClient_VolumeUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// VolumesPrune provides a mock function for the type MockAPIClient
func (_mock *MockAPIClient) VolumesPrune(ctx context.Context, pruneFilter filters.Args) (volume.PruneReport, error) {
	ret := _mock.Called(ctx, pruneFilter)

	if len(ret) == 0 {
		panic("no return value specified for VolumesPrune")
	}

	var r0 volume.PruneReport
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) (volume.PruneReport, error)); ok {
		return returnFunc(ctx, pruneFilter)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, filters.Args) volume.PruneReport); ok {
		r0 = returnFunc(ctx, pruneFilter)
	} else {
		r0 = ret.Get(0).(volume.PruneReport)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, filters.Args) error); ok {
		r1 = returnFunc(ctx, pruneFilter)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockAPIClient_VolumesPrune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VolumesPrune'
type MockAPIClient_VolumesPrune_Call struct {
	*mock.Call
}

// VolumesPrune is a helper method to define mock.On call
//   - ctx context.Context
//   - pruneFilter filters.Args
func (_e *MockAPIClient_Expecter) VolumesPrune(ctx any, pruneFilter any) *MockAPIClient_VolumesPrune_Call {
	return &MockAPIClient_VolumesPrune_Call{Call: _e.mock.On("VolumesPrune", ctx, pruneFilter)}
}

func (_c *MockAPIClient_VolumesPrune_Call) Run(run func(ctx context.Context, pruneFilter filters.Args)) *MockAPIClient_VolumesPrune_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 filters.Args
		if args[1] != nil {
			arg1 = args[1].(filters.Args)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockAPIClient_VolumesPrune_Call) Return(pruneReport volume.PruneReport, err error) *MockAPIClient_VolumesPrune_Call {
	_c.Call.Return(pruneReport, err)
	return _c
}

func (_c *MockAPIClient_VolumesPrune_Call) RunAndReturn(run func(ctx context.Context, pruneFilter filters.Args) (volume.PruneReport, error)) *MockAPIClient_VolumesPrune_Call {
	_c.Call.Return(run)
	return _c
}