// 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"
)

// MockRegistrySvcAPI is a mock of RegistrySvcAPI interface.
type MockRegistrySvcAPI struct {
	ctrl     *gomock.Controller
	recorder *MockRegistrySvcAPIMockRecorder
	isgomock struct{}
}

// MockRegistrySvcAPIMockRecorder is the mock recorder for MockRegistrySvcAPI.
type MockRegistrySvcAPIMockRecorder struct {
	mock *MockRegistrySvcAPI
}

// NewMockRegistrySvcAPI creates a new mock instance.
func NewMockRegistrySvcAPI(ctrl *gomock.Controller) *MockRegistrySvcAPI {
	mock := &MockRegistrySvcAPI{ctrl: ctrl}
	mock.recorder = &MockRegistrySvcAPIMockRecorder{mock}
	return mock
}

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

// DeleteDefinition mocks base method.
func (m *MockRegistrySvcAPI) DeleteDefinition(ctx context.Context, id string) ApiDeleteDefinitionRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDefinition", ctx, id)
	ret0, _ := ret[0].(ApiDeleteDefinitionRequest)
	return ret0
}

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

// DeleteDefinitionExecute mocks base method.
func (m *MockRegistrySvcAPI) DeleteDefinitionExecute(r ApiDeleteDefinitionRequest) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDefinitionExecute", r)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNode mocks base method.
func (m *MockRegistrySvcAPI) DeleteNode(ctx context.Context, url string) ApiDeleteNodeRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNode", ctx, url)
	ret0, _ := ret[0].(ApiDeleteNodeRequest)
	return ret0
}

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

// DeleteNodeExecute mocks base method.
func (m *MockRegistrySvcAPI) DeleteNodeExecute(r ApiDeleteNodeRequest) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodeExecute", r)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RemoveInstance mocks base method.
func (m *MockRegistrySvcAPI) RemoveInstance(ctx context.Context, id string) ApiRemoveInstanceRequest {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstance", ctx, id)
	ret0, _ := ret[0].(ApiRemoveInstanceRequest)
	return ret0
}

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

// RemoveInstanceExecute mocks base method.
func (m *MockRegistrySvcAPI) RemoveInstanceExecute(r ApiRemoveInstanceRequest) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstanceExecute", r)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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