// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/docker/mover.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockImageDiskLoader is a mock of ImageDiskLoader interface.
type MockImageDiskLoader struct {
	ctrl     *gomock.Controller
	recorder *MockImageDiskLoaderMockRecorder
}

// MockImageDiskLoaderMockRecorder is the mock recorder for MockImageDiskLoader.
type MockImageDiskLoaderMockRecorder struct {
	mock *MockImageDiskLoader
}

// NewMockImageDiskLoader creates a new mock instance.
func NewMockImageDiskLoader(ctrl *gomock.Controller) *MockImageDiskLoader {
	mock := &MockImageDiskLoader{ctrl: ctrl}
	mock.recorder = &MockImageDiskLoaderMockRecorder{mock}
	return mock
}

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

// LoadFromFile mocks base method.
func (m *MockImageDiskLoader) LoadFromFile(ctx context.Context, filepath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadFromFile", ctx, filepath)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadFromFile indicates an expected call of LoadFromFile.
func (mr *MockImageDiskLoaderMockRecorder) LoadFromFile(ctx, filepath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadFromFile", reflect.TypeOf((*MockImageDiskLoader)(nil).LoadFromFile), ctx, filepath)
}

// MockImageDiskWriter is a mock of ImageDiskWriter interface.
type MockImageDiskWriter struct {
	ctrl     *gomock.Controller
	recorder *MockImageDiskWriterMockRecorder
}

// MockImageDiskWriterMockRecorder is the mock recorder for MockImageDiskWriter.
type MockImageDiskWriterMockRecorder struct {
	mock *MockImageDiskWriter
}

// NewMockImageDiskWriter creates a new mock instance.
func NewMockImageDiskWriter(ctrl *gomock.Controller) *MockImageDiskWriter {
	mock := &MockImageDiskWriter{ctrl: ctrl}
	mock.recorder = &MockImageDiskWriterMockRecorder{mock}
	return mock
}

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

// SaveToFile mocks base method.
func (m *MockImageDiskWriter) SaveToFile(ctx context.Context, filepath string, images ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, filepath}
	for _, a := range images {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SaveToFile", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveToFile indicates an expected call of SaveToFile.
func (mr *MockImageDiskWriterMockRecorder) SaveToFile(ctx, filepath interface{}, images ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, filepath}, images...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveToFile", reflect.TypeOf((*MockImageDiskWriter)(nil).SaveToFile), varargs...)
}

// MockImageTaggerPusher is a mock of ImageTaggerPusher interface.
type MockImageTaggerPusher struct {
	ctrl     *gomock.Controller
	recorder *MockImageTaggerPusherMockRecorder
}

// MockImageTaggerPusherMockRecorder is the mock recorder for MockImageTaggerPusher.
type MockImageTaggerPusherMockRecorder struct {
	mock *MockImageTaggerPusher
}

// NewMockImageTaggerPusher creates a new mock instance.
func NewMockImageTaggerPusher(ctrl *gomock.Controller) *MockImageTaggerPusher {
	mock := &MockImageTaggerPusher{ctrl: ctrl}
	mock.recorder = &MockImageTaggerPusherMockRecorder{mock}
	return mock
}

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

// PushImage mocks base method.
func (m *MockImageTaggerPusher) PushImage(ctx context.Context, image, endpoint string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushImage", ctx, image, endpoint)
	ret0, _ := ret[0].(error)
	return ret0
}

// PushImage indicates an expected call of PushImage.
func (mr *MockImageTaggerPusherMockRecorder) PushImage(ctx, image, endpoint interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushImage", reflect.TypeOf((*MockImageTaggerPusher)(nil).PushImage), ctx, image, endpoint)
}

// TagImage mocks base method.
func (m *MockImageTaggerPusher) TagImage(ctx context.Context, image, endpoint string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagImage", ctx, image, endpoint)
	ret0, _ := ret[0].(error)
	return ret0
}

// TagImage indicates an expected call of TagImage.
func (mr *MockImageTaggerPusherMockRecorder) TagImage(ctx, image, endpoint interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagImage", reflect.TypeOf((*MockImageTaggerPusher)(nil).TagImage), ctx, image, endpoint)
}

// MockImagePuller is a mock of ImagePuller interface.
type MockImagePuller struct {
	ctrl     *gomock.Controller
	recorder *MockImagePullerMockRecorder
}

// MockImagePullerMockRecorder is the mock recorder for MockImagePuller.
type MockImagePullerMockRecorder struct {
	mock *MockImagePuller
}

// NewMockImagePuller creates a new mock instance.
func NewMockImagePuller(ctrl *gomock.Controller) *MockImagePuller {
	mock := &MockImagePuller{ctrl: ctrl}
	mock.recorder = &MockImagePullerMockRecorder{mock}
	return mock
}

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

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

// PullImage indicates an expected call of PullImage.
func (mr *MockImagePullerMockRecorder) PullImage(ctx, image interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockImagePuller)(nil).PullImage), ctx, image)
}

// MockDockerClient is a mock of DockerClient interface.
type MockDockerClient struct {
	ctrl     *gomock.Controller
	recorder *MockDockerClientMockRecorder
}

// MockDockerClientMockRecorder is the mock recorder for MockDockerClient.
type MockDockerClientMockRecorder struct {
	mock *MockDockerClient
}

// NewMockDockerClient creates a new mock instance.
func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient {
	mock := &MockDockerClient{ctrl: ctrl}
	mock.recorder = &MockDockerClientMockRecorder{mock}
	return mock
}

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

// LoadFromFile mocks base method.
func (m *MockDockerClient) LoadFromFile(ctx context.Context, filepath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadFromFile", ctx, filepath)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadFromFile indicates an expected call of LoadFromFile.
func (mr *MockDockerClientMockRecorder) LoadFromFile(ctx, filepath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadFromFile", reflect.TypeOf((*MockDockerClient)(nil).LoadFromFile), ctx, filepath)
}

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

// PullImage indicates an expected call of PullImage.
func (mr *MockDockerClientMockRecorder) PullImage(ctx, image interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockDockerClient)(nil).PullImage), ctx, image)
}

// SaveToFile mocks base method.
func (m *MockDockerClient) SaveToFile(ctx context.Context, filepath string, images ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, filepath}
	for _, a := range images {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SaveToFile", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveToFile indicates an expected call of SaveToFile.
func (mr *MockDockerClientMockRecorder) SaveToFile(ctx, filepath interface{}, images ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, filepath}, images...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveToFile", reflect.TypeOf((*MockDockerClient)(nil).SaveToFile), varargs...)
}

// MockImageSource is a mock of ImageSource interface.
type MockImageSource struct {
	ctrl     *gomock.Controller
	recorder *MockImageSourceMockRecorder
}

// MockImageSourceMockRecorder is the mock recorder for MockImageSource.
type MockImageSourceMockRecorder struct {
	mock *MockImageSource
}

// NewMockImageSource creates a new mock instance.
func NewMockImageSource(ctrl *gomock.Controller) *MockImageSource {
	mock := &MockImageSource{ctrl: ctrl}
	mock.recorder = &MockImageSourceMockRecorder{mock}
	return mock
}

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

// Load mocks base method.
func (m *MockImageSource) Load(ctx context.Context, images ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range images {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Load", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Load indicates an expected call of Load.
func (mr *MockImageSourceMockRecorder) Load(ctx interface{}, images ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, images...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockImageSource)(nil).Load), varargs...)
}

// MockImageDestination is a mock of ImageDestination interface.
type MockImageDestination struct {
	ctrl     *gomock.Controller
	recorder *MockImageDestinationMockRecorder
}

// MockImageDestinationMockRecorder is the mock recorder for MockImageDestination.
type MockImageDestinationMockRecorder struct {
	mock *MockImageDestination
}

// NewMockImageDestination creates a new mock instance.
func NewMockImageDestination(ctrl *gomock.Controller) *MockImageDestination {
	mock := &MockImageDestination{ctrl: ctrl}
	mock.recorder = &MockImageDestinationMockRecorder{mock}
	return mock
}

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

// Write mocks base method.
func (m *MockImageDestination) Write(ctx context.Context, images ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range images {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockImageDestinationMockRecorder) Write(ctx interface{}, images ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, images...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockImageDestination)(nil).Write), varargs...)
}
