// Code generated by MockGen. DO NOT EDIT.
//
// Generated by this command:
//
//

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

import (
	context "context"
	http "net/http"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockContainerSvcAPI is a mock of ContainerSvcAPI interface.
type MockContainerSvcAPI struct {
	ctrl     *gomock.Controller
	recorder *MockContainerSvcAPIMockRecorder
	isgomock struct{}
}

// MockContainerSvcAPIMockRecorder is the mock recorder for MockContainerSvcAPI.
type MockContainerSvcAPIMockRecorder struct {
	mock *MockContainerSvcAPI
}

// NewMockContainerSvcAPI creates a new mock instance.
func NewMockContainerSvcAPI(ctrl *gomock.Controller) *MockContainerSvcAPI {
	mock := &MockContainerSvcAPI{ctrl: ctrl}
	mock.recorder = &MockContainerSvcAPIMockRecorder{mock}
	return mock
}

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

// BuildImage mocks base method.
func (m *MockContainerSvcAPI) BuildImage(ctx context.Context) ApiBuildImageRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildImage", ctx)
	ret0, _ := ret[0].(ApiBuildImageRequest)
	return ret0
}

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

// BuildImageExecute mocks base method.
func (m *MockContainerSvcAPI) BuildImageExecute(r ApiBuildImageRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildImageExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// BuildImageExecute indicates an expected call of BuildImageExecute.
func (mr *MockContainerSvcAPIMockRecorder) BuildImageExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildImageExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).BuildImageExecute), r)
}

// ContainerDaemonInfo mocks base method.
func (m *MockContainerSvcAPI) ContainerDaemonInfo(ctx context.Context) ApiContainerDaemonInfoRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerDaemonInfo", ctx)
	ret0, _ := ret[0].(ApiContainerDaemonInfoRequest)
	return ret0
}

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

// ContainerDaemonInfoExecute mocks base method.
func (m *MockContainerSvcAPI) ContainerDaemonInfoExecute(r ApiContainerDaemonInfoRequest) (*ContainerSvcDaemonInfoResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerDaemonInfoExecute", r)
	ret0, _ := ret[0].(*ContainerSvcDaemonInfoResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ContainerDaemonInfoExecute indicates an expected call of ContainerDaemonInfoExecute.
func (mr *MockContainerSvcAPIMockRecorder) ContainerDaemonInfoExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerDaemonInfoExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ContainerDaemonInfoExecute), r)
}

// ContainerIsRunning mocks base method.
func (m *MockContainerSvcAPI) ContainerIsRunning(ctx context.Context) ApiContainerIsRunningRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerIsRunning", ctx)
	ret0, _ := ret[0].(ApiContainerIsRunningRequest)
	return ret0
}

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

// ContainerIsRunningExecute mocks base method.
func (m *MockContainerSvcAPI) ContainerIsRunningExecute(r ApiContainerIsRunningRequest) (*ContainerSvcContainerIsRunningResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerIsRunningExecute", r)
	ret0, _ := ret[0].(*ContainerSvcContainerIsRunningResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ContainerIsRunningExecute indicates an expected call of ContainerIsRunningExecute.
func (mr *MockContainerSvcAPIMockRecorder) ContainerIsRunningExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerIsRunningExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ContainerIsRunningExecute), r)
}

// ContainerSummary mocks base method.
func (m *MockContainerSvcAPI) ContainerSummary(ctx context.Context) ApiContainerSummaryRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerSummary", ctx)
	ret0, _ := ret[0].(ApiContainerSummaryRequest)
	return ret0
}

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

// ContainerSummaryExecute mocks base method.
func (m *MockContainerSvcAPI) ContainerSummaryExecute(r ApiContainerSummaryRequest) (*ContainerSvcGetContainerSummaryResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerSummaryExecute", r)
	ret0, _ := ret[0].(*ContainerSvcGetContainerSummaryResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ContainerSummaryExecute indicates an expected call of ContainerSummaryExecute.
func (mr *MockContainerSvcAPIMockRecorder) ContainerSummaryExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerSummaryExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ContainerSummaryExecute), r)
}

// GetHost mocks base method.
func (m *MockContainerSvcAPI) GetHost(ctx context.Context) ApiGetHostRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHost", ctx)
	ret0, _ := ret[0].(ApiGetHostRequest)
	return ret0
}

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

// GetHostExecute mocks base method.
func (m *MockContainerSvcAPI) GetHostExecute(r ApiGetHostRequest) (*ContainerSvcGetHostResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHostExecute", r)
	ret0, _ := ret[0].(*ContainerSvcGetHostResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetHostExecute indicates an expected call of GetHostExecute.
func (mr *MockContainerSvcAPIMockRecorder) GetHostExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).GetHostExecute), r)
}

// ImagePullable mocks base method.
func (m *MockContainerSvcAPI) ImagePullable(ctx context.Context, imageName string) ApiImagePullableRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImagePullable", ctx, imageName)
	ret0, _ := ret[0].(ApiImagePullableRequest)
	return ret0
}

// ImagePullable indicates an expected call of ImagePullable.
func (mr *MockContainerSvcAPIMockRecorder) ImagePullable(ctx, imageName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePullable", reflect.TypeOf((*MockContainerSvcAPI)(nil).ImagePullable), ctx, imageName)
}

// ImagePullableExecute mocks base method.
func (m *MockContainerSvcAPI) ImagePullableExecute(r ApiImagePullableRequest) (*ContainerSvcImagePullableResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImagePullableExecute", r)
	ret0, _ := ret[0].(*ContainerSvcImagePullableResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ImagePullableExecute indicates an expected call of ImagePullableExecute.
func (mr *MockContainerSvcAPIMockRecorder) ImagePullableExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImagePullableExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ImagePullableExecute), r)
}

// ListContainerLogs mocks base method.
func (m *MockContainerSvcAPI) ListContainerLogs(ctx context.Context) ApiListContainerLogsRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainerLogs", ctx)
	ret0, _ := ret[0].(ApiListContainerLogsRequest)
	return ret0
}

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

// ListContainerLogsExecute mocks base method.
func (m *MockContainerSvcAPI) ListContainerLogsExecute(r ApiListContainerLogsRequest) (*ContainerSvcListLogsResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainerLogsExecute", r)
	ret0, _ := ret[0].(*ContainerSvcListLogsResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListContainerLogsExecute indicates an expected call of ListContainerLogsExecute.
func (mr *MockContainerSvcAPIMockRecorder) ListContainerLogsExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainerLogsExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ListContainerLogsExecute), r)
}

// ListContainers mocks base method.
func (m *MockContainerSvcAPI) ListContainers(ctx context.Context) ApiListContainersRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainers", ctx)
	ret0, _ := ret[0].(ApiListContainersRequest)
	return ret0
}

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

// ListContainersExecute mocks base method.
func (m *MockContainerSvcAPI) ListContainersExecute(r ApiListContainersRequest) (*ContainerSvcListContainersResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainersExecute", r)
	ret0, _ := ret[0].(*ContainerSvcListContainersResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListContainersExecute indicates an expected call of ListContainersExecute.
func (mr *MockContainerSvcAPIMockRecorder) ListContainersExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainersExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).ListContainersExecute), r)
}

// RunContainer mocks base method.
func (m *MockContainerSvcAPI) RunContainer(ctx context.Context) ApiRunContainerRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunContainer", ctx)
	ret0, _ := ret[0].(ApiRunContainerRequest)
	return ret0
}

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

// RunContainerExecute mocks base method.
func (m *MockContainerSvcAPI) RunContainerExecute(r ApiRunContainerRequest) (*ContainerSvcRunContainerResponse, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunContainerExecute", r)
	ret0, _ := ret[0].(*ContainerSvcRunContainerResponse)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RunContainerExecute indicates an expected call of RunContainerExecute.
func (mr *MockContainerSvcAPIMockRecorder) RunContainerExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunContainerExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).RunContainerExecute), r)
}

// StopContainer mocks base method.
func (m *MockContainerSvcAPI) StopContainer(ctx context.Context) ApiStopContainerRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopContainer", ctx)
	ret0, _ := ret[0].(ApiStopContainerRequest)
	return ret0
}

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

// StopContainerExecute mocks base method.
func (m *MockContainerSvcAPI) StopContainerExecute(r ApiStopContainerRequest) (map[string]any, *http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopContainerExecute", r)
	ret0, _ := ret[0].(map[string]any)
	ret1, _ := ret[1].(*http.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// StopContainerExecute indicates an expected call of StopContainerExecute.
func (mr *MockContainerSvcAPIMockRecorder) StopContainerExecute(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainerExecute", reflect.TypeOf((*MockContainerSvcAPI)(nil).StopContainerExecute), r)
}
