client_mock_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/thediveo/morbyd/moby (interfaces: Client)
//
// Generated by this command:
//
//	mockgen -write_package_comment=false -destination client_mock_test.go -package morbyd github.com/thediveo/morbyd/moby Client
//

package morbyd

import (
	context "context"
	io "io"
	reflect "reflect"

	client "github.com/moby/moby/client"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
	isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockClient) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
}

// ContainerAttach mocks base method.
func (m *MockClient) ContainerAttach(ctx context.Context, containerID string, options client.ContainerAttachOptions) (client.ContainerAttachResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerAttach", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerAttachResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerAttach indicates an expected call of ContainerAttach.
func (mr *MockClientMockRecorder) ContainerAttach(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerAttach", reflect.TypeOf((*MockClient)(nil).ContainerAttach), ctx, containerID, options)
}

// ContainerCreate mocks base method.
func (m *MockClient) ContainerCreate(ctx context.Context, options client.ContainerCreateOptions) (client.ContainerCreateResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerCreate", ctx, options)
	ret0, _ := ret[0].(client.ContainerCreateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerCreate indicates an expected call of ContainerCreate.
func (mr *MockClientMockRecorder) ContainerCreate(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerCreate", reflect.TypeOf((*MockClient)(nil).ContainerCreate), ctx, options)
}

// ContainerInspect mocks base method.
func (m *MockClient) ContainerInspect(ctx context.Context, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerInspect", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerInspectResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerInspect indicates an expected call of ContainerInspect.
func (mr *MockClientMockRecorder) ContainerInspect(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerInspect", reflect.TypeOf((*MockClient)(nil).ContainerInspect), ctx, containerID, options)
}

// ContainerKill mocks base method.
func (m *MockClient) ContainerKill(ctx context.Context, containerID string, options client.ContainerKillOptions) (client.ContainerKillResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerKill", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerKillResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerKill indicates an expected call of ContainerKill.
func (mr *MockClientMockRecorder) ContainerKill(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerKill", reflect.TypeOf((*MockClient)(nil).ContainerKill), ctx, containerID, options)
}

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

// ContainerList indicates an expected call of ContainerList.
func (mr *MockClientMockRecorder) ContainerList(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerList", reflect.TypeOf((*MockClient)(nil).ContainerList), ctx, options)
}

// ContainerPause mocks base method.
func (m *MockClient) ContainerPause(ctx context.Context, containerID string, options client.ContainerPauseOptions) (client.ContainerPauseResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerPause", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerPauseResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerPause indicates an expected call of ContainerPause.
func (mr *MockClientMockRecorder) ContainerPause(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerPause", reflect.TypeOf((*MockClient)(nil).ContainerPause), ctx, containerID, options)
}

// ContainerRemove mocks base method.
func (m *MockClient) ContainerRemove(ctx context.Context, containerID string, options client.ContainerRemoveOptions) (client.ContainerRemoveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerRemove", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerRemoveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerRemove indicates an expected call of ContainerRemove.
func (mr *MockClientMockRecorder) ContainerRemove(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRemove", reflect.TypeOf((*MockClient)(nil).ContainerRemove), ctx, containerID, options)
}

// ContainerRename mocks base method.
func (m *MockClient) ContainerRename(ctx context.Context, containerID string, options client.ContainerRenameOptions) (client.ContainerRenameResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerRename", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerRenameResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerRename indicates an expected call of ContainerRename.
func (mr *MockClientMockRecorder) ContainerRename(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRename", reflect.TypeOf((*MockClient)(nil).ContainerRename), ctx, containerID, options)
}

// ContainerRestart mocks base method.
func (m *MockClient) ContainerRestart(ctx context.Context, containerID string, options client.ContainerRestartOptions) (client.ContainerRestartResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerRestart", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerRestartResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerRestart indicates an expected call of ContainerRestart.
func (mr *MockClientMockRecorder) ContainerRestart(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerRestart", reflect.TypeOf((*MockClient)(nil).ContainerRestart), ctx, containerID, options)
}

// ContainerStart mocks base method.
func (m *MockClient) ContainerStart(ctx context.Context, containerID string, options client.ContainerStartOptions) (client.ContainerStartResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerStart", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerStartResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStart indicates an expected call of ContainerStart.
func (mr *MockClientMockRecorder) ContainerStart(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStart", reflect.TypeOf((*MockClient)(nil).ContainerStart), ctx, containerID, options)
}

// ContainerStop mocks base method.
func (m *MockClient) ContainerStop(ctx context.Context, containerID string, options client.ContainerStopOptions) (client.ContainerStopResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerStop", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerStopResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerStop indicates an expected call of ContainerStop.
func (mr *MockClientMockRecorder) ContainerStop(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerStop", reflect.TypeOf((*MockClient)(nil).ContainerStop), ctx, containerID, options)
}

// ContainerUnpause mocks base method.
func (m *MockClient) ContainerUnpause(ctx context.Context, containerID string, options client.ContainerUnpauseOptions) (client.ContainerUnpauseResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerUnpause", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerUnpauseResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerUnpause indicates an expected call of ContainerUnpause.
func (mr *MockClientMockRecorder) ContainerUnpause(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerUnpause", reflect.TypeOf((*MockClient)(nil).ContainerUnpause), ctx, containerID, options)
}

// ContainerWait mocks base method.
func (m *MockClient) ContainerWait(ctx context.Context, containerID string, options client.ContainerWaitOptions) client.ContainerWaitResult {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerWait", ctx, containerID, options)
	ret0, _ := ret[0].(client.ContainerWaitResult)
	return ret0
}

// ContainerWait indicates an expected call of ContainerWait.
func (mr *MockClientMockRecorder) ContainerWait(ctx, containerID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerWait", reflect.TypeOf((*MockClient)(nil).ContainerWait), ctx, containerID, options)
}

// ExecAttach mocks base method.
func (m *MockClient) ExecAttach(ctx context.Context, execID string, options client.ExecAttachOptions) (client.ExecAttachResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecAttach", ctx, execID, options)
	ret0, _ := ret[0].(client.ExecAttachResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecAttach indicates an expected call of ExecAttach.
func (mr *MockClientMockRecorder) ExecAttach(ctx, execID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecAttach", reflect.TypeOf((*MockClient)(nil).ExecAttach), ctx, execID, options)
}

// ExecCreate mocks base method.
func (m *MockClient) ExecCreate(ctx context.Context, container string, options client.ExecCreateOptions) (client.ExecCreateResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecCreate", ctx, container, options)
	ret0, _ := ret[0].(client.ExecCreateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecCreate indicates an expected call of ExecCreate.
func (mr *MockClientMockRecorder) ExecCreate(ctx, container, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecCreate", reflect.TypeOf((*MockClient)(nil).ExecCreate), ctx, container, options)
}

// ExecInspect mocks base method.
func (m *MockClient) ExecInspect(ctx context.Context, execID string, options client.ExecInspectOptions) (client.ExecInspectResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecInspect", ctx, execID, options)
	ret0, _ := ret[0].(client.ExecInspectResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecInspect indicates an expected call of ExecInspect.
func (mr *MockClientMockRecorder) ExecInspect(ctx, execID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecInspect", reflect.TypeOf((*MockClient)(nil).ExecInspect), ctx, execID, options)
}

// ExecStart mocks base method.
func (m *MockClient) ExecStart(ctx context.Context, execID string, options client.ExecStartOptions) (client.ExecStartResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecStart", ctx, execID, options)
	ret0, _ := ret[0].(client.ExecStartResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecStart indicates an expected call of ExecStart.
func (mr *MockClientMockRecorder) ExecStart(ctx, execID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecStart", reflect.TypeOf((*MockClient)(nil).ExecStart), ctx, execID, options)
}

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

// ImageBuild indicates an expected call of ImageBuild.
func (mr *MockClientMockRecorder) ImageBuild(ctx, buildContext, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageBuild", reflect.TypeOf((*MockClient)(nil).ImageBuild), ctx, buildContext, options)
}

// ImageInspect mocks base method.
func (m *MockClient) ImageInspect(ctx context.Context, imageID string, inspectOpts ...client.ImageInspectOption) (client.ImageInspectResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, imageID}
	for _, a := range inspectOpts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImageInspect", varargs...)
	ret0, _ := ret[0].(client.ImageInspectResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageInspect indicates an expected call of ImageInspect.
func (mr *MockClientMockRecorder) ImageInspect(ctx, imageID any, inspectOpts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, imageID}, inspectOpts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageInspect", reflect.TypeOf((*MockClient)(nil).ImageInspect), varargs...)
}

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

// ImageList indicates an expected call of ImageList.
func (mr *MockClientMockRecorder) ImageList(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageList", reflect.TypeOf((*MockClient)(nil).ImageList), ctx, options)
}

// ImagePull mocks base method.
func (m *MockClient) ImagePull(ctx context.Context, refStr string, options client.ImagePullOptions) (client.ImagePullResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImagePull", ctx, refStr, options)
	ret0, _ := ret[0].(client.ImagePullResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePull indicates an expected call of ImagePull.
func (mr *MockClientMockRecorder) ImagePull(ctx, refStr, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePull", reflect.TypeOf((*MockClient)(nil).ImagePull), ctx, refStr, options)
}

// ImagePush mocks base method.
func (m *MockClient) ImagePush(ctx context.Context, image string, options client.ImagePushOptions) (client.ImagePushResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImagePush", ctx, image, options)
	ret0, _ := ret[0].(client.ImagePushResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImagePush indicates an expected call of ImagePush.
func (mr *MockClientMockRecorder) ImagePush(ctx, image, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePush", reflect.TypeOf((*MockClient)(nil).ImagePush), ctx, image, options)
}

// ImageRemove mocks base method.
func (m *MockClient) ImageRemove(ctx context.Context, imageID string, options client.ImageRemoveOptions) (client.ImageRemoveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImageRemove", ctx, imageID, options)
	ret0, _ := ret[0].(client.ImageRemoveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageRemove indicates an expected call of ImageRemove.
func (mr *MockClientMockRecorder) ImageRemove(ctx, imageID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageRemove", reflect.TypeOf((*MockClient)(nil).ImageRemove), ctx, imageID, options)
}

// ImageTag mocks base method.
func (m *MockClient) ImageTag(ctx context.Context, options client.ImageTagOptions) (client.ImageTagResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImageTag", ctx, options)
	ret0, _ := ret[0].(client.ImageTagResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImageTag indicates an expected call of ImageTag.
func (mr *MockClientMockRecorder) ImageTag(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImageTag", reflect.TypeOf((*MockClient)(nil).ImageTag), ctx, options)
}

// NetworkCreate mocks base method.
func (m *MockClient) NetworkCreate(ctx context.Context, name string, options client.NetworkCreateOptions) (client.NetworkCreateResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkCreate", ctx, name, options)
	ret0, _ := ret[0].(client.NetworkCreateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkCreate indicates an expected call of NetworkCreate.
func (mr *MockClientMockRecorder) NetworkCreate(ctx, name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkCreate", reflect.TypeOf((*MockClient)(nil).NetworkCreate), ctx, name, options)
}

// NetworkInspect mocks base method.
func (m *MockClient) NetworkInspect(ctx context.Context, networkID string, options client.NetworkInspectOptions) (client.NetworkInspectResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkInspect", ctx, networkID, options)
	ret0, _ := ret[0].(client.NetworkInspectResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkInspect indicates an expected call of NetworkInspect.
func (mr *MockClientMockRecorder) NetworkInspect(ctx, networkID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInspect", reflect.TypeOf((*MockClient)(nil).NetworkInspect), ctx, networkID, options)
}

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

// NetworkList indicates an expected call of NetworkList.
func (mr *MockClientMockRecorder) NetworkList(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkList", reflect.TypeOf((*MockClient)(nil).NetworkList), ctx, options)
}

// NetworkRemove mocks base method.
func (m *MockClient) NetworkRemove(ctx context.Context, networkID string, options client.NetworkRemoveOptions) (client.NetworkRemoveResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkRemove", ctx, networkID, options)
	ret0, _ := ret[0].(client.NetworkRemoveResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NetworkRemove indicates an expected call of NetworkRemove.
func (mr *MockClientMockRecorder) NetworkRemove(ctx, networkID, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkRemove", reflect.TypeOf((*MockClient)(nil).NetworkRemove), ctx, networkID, options)
}

// ServerVersion mocks base method.
func (m *MockClient) ServerVersion(ctx context.Context, arg1 client.ServerVersionOptions) (client.ServerVersionResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerVersion", ctx, arg1)
	ret0, _ := ret[0].(client.ServerVersionResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ServerVersion indicates an expected call of ServerVersion.
func (mr *MockClientMockRecorder) ServerVersion(ctx, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerVersion", reflect.TypeOf((*MockClient)(nil).ServerVersion), ctx, arg1)
}